* *.cs: Upgrade to new NUnit style.
svn path=/trunk/mcs/; revision=136968
namespace MonoTests.System.Security.Cryptography.Xml {
- public class AssertCrypto : Assertion {
+ public class AssertCrypto {
// because most crypto stuff works with byte[] buffers
static public void AssertEquals (string msg, byte[] array1, byte[] array2)
if ((array1 == null) && (array2 == null))
return;
if (array1 == null)
- Fail (msg + " -> First array is NULL");
+ Assert.Fail (msg + " -> First array is NULL");
if (array2 == null)
- Fail (msg + " -> Second array is NULL");
+ Assert.Fail (msg + " -> Second array is NULL");
bool a = (array1.Length == array2.Length);
if (a) {
}
msg += " -> Expected " + BitConverter.ToString (array1, 0);
msg += " is different than " + BitConverter.ToString (array2, 0);
- Assert (msg, a);
+ Assert.IsTrue (a, msg);
}
private const string xmldsig = " xmlns=\"http://www.w3.org/2000/09/xmldsig#\"";
{
expected = expected.Replace (xmldsig, String.Empty);
actual = actual.Replace (xmldsig, String.Empty);
- AssertEquals (msg, expected, actual);
+ Assert.AreEqual (expected, actual, msg);
}
}
}
+2009-06-26 Robert Jordan <robertj@gmx.net>
+
+ * *.cs: Upgrade to new NUnit style.
+
2008-11-01 Sebastien Pouliot <sebastien@ximian.com>
* EncryptedXmlTest.cs: Add null check test cases for many methods.
namespace MonoTests.System.Security.Cryptography.Xml {
[TestFixture]
- public class DSAKeyValueTest : Assertion {
+ public class DSAKeyValueTest {
[Test]
public void GenerateKey ()
{
DSAKeyValue dsa1 = new DSAKeyValue ();
- AssertNotNull ("Key", dsa1.Key);
+ Assert.IsNotNull (dsa1.Key, "Key");
XmlElement xmlkey = dsa1.GetXml ();
DSAKeyValue dsa2 = new DSAKeyValue ();
dsa2.LoadXml (xmlkey);
- Assert ("dsa1==dsa2", (dsa1.GetXml ().OuterXml) == (dsa2.GetXml ().OuterXml));
+ Assert.IsTrue ((dsa1.GetXml ().OuterXml) == (dsa2.GetXml ().OuterXml), "dsa1==dsa2");
DSA key = dsa1.Key;
DSAKeyValue dsa3 = new DSAKeyValue (key);
- Assert ("dsa3==dsa1", (dsa3.GetXml ().OuterXml) == (dsa1.GetXml ().OuterXml));
- Assert ("dsa3==dsa2", (dsa3.GetXml ().OuterXml) == (dsa2.GetXml ().OuterXml));
+ Assert.IsTrue ((dsa3.GetXml ().OuterXml) == (dsa1.GetXml ().OuterXml), "dsa3==dsa1");
+ Assert.IsTrue ((dsa3.GetXml ().OuterXml) == (dsa2.GetXml ().OuterXml), "dsa3==dsa2");
}
[Test]
dsa1.LoadXml (doc.DocumentElement);
string s = (dsa1.GetXml ().OuterXml);
- AssertEquals ("DSA Key", dsaKey, s);
+ Assert.AreEqual (dsaKey, s, "DSA Key");
}
[Test]
namespace MonoTests.System.Security.Cryptography.Xml {
[TestFixture]
- public class DataObjectTest : Assertion {
+ public class DataObjectTest {
[Test]
public void NewDataObject ()
doc.LoadXml (test);
DataObject obj1 = new DataObject ();
- Assert ("Data.Count==0", (obj1.Data.Count == 0));
- AssertEquals ("Just constructed", "<Object xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (obj1.GetXml ().OuterXml));
+ Assert.IsTrue ((obj1.Data.Count == 0), "Data.Count==0");
+ Assert.AreEqual ("<Object xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (obj1.GetXml ().OuterXml), "Just constructed");
obj1.Id = "id";
obj1.MimeType = "mime";
obj1.Encoding = "encoding";
- AssertEquals ("Only attributes", "<Object Id=\"id\" MimeType=\"mime\" Encoding=\"encoding\" xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (obj1.GetXml ().OuterXml));
+ Assert.AreEqual ("<Object Id=\"id\" MimeType=\"mime\" Encoding=\"encoding\" xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (obj1.GetXml ().OuterXml), "Only attributes");
obj1.Data = doc.ChildNodes;
- Assert ("Data.Count==1", (obj1.Data.Count == 1));
+ Assert.IsTrue ((obj1.Data.Count == 1), "Data.Count==1");
XmlElement xel = obj1.GetXml ();
DataObject obj2 = new DataObject ();
obj2.LoadXml (xel);
- AssertEquals ("obj1==obj2", (obj1.GetXml ().OuterXml), (obj2.GetXml ().OuterXml));
+ Assert.AreEqual ((obj1.GetXml ().OuterXml), (obj2.GetXml ().OuterXml), "obj1==obj2");
DataObject obj3 = new DataObject (obj1.Id, obj1.MimeType, obj1.Encoding, doc.DocumentElement);
- AssertEquals ("obj2==obj3", (obj2.GetXml ().OuterXml), (obj3.GetXml ().OuterXml));
+ Assert.AreEqual ((obj2.GetXml ().OuterXml), (obj3.GetXml ().OuterXml), "obj2==obj3");
}
[Test]
DataObject obj1 = new DataObject ();
obj1.LoadXml (doc.DocumentElement);
- Assert ("Data.Count==2", (obj1.Data.Count == 2));
+ Assert.IsTrue ((obj1.Data.Count == 2), "Data.Count==2");
string s = (obj1.GetXml ().OuterXml);
- AssertEquals ("DataObject 1", value1, s);
+ Assert.AreEqual (value1, s, "DataObject 1");
string value2 = "<Object xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><Test xmlns=\"\" /></Object>";
doc = new XmlDocument ();
obj2.LoadXml (doc.DocumentElement);
s = (obj2.GetXml ().OuterXml);
- AssertEquals ("DataObject 2", value2, s);
+ Assert.AreEqual (value2, s, "DataObject 2");
string value3 = "<Object Id=\"id\" xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><Test xmlns=\"\" /></Object>";
doc = new XmlDocument ();
obj3.LoadXml (doc.DocumentElement);
s = (obj3.GetXml ().OuterXml);
- AssertEquals ("DataObject 3", value3, s);
+ Assert.AreEqual (value3, s, "DataObject 3");
string value4 = "<Object MimeType=\"mime\" xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><Test xmlns=\"\" /></Object>";
doc = new XmlDocument ();
obj4.LoadXml (doc.DocumentElement);
s = (obj4.GetXml ().OuterXml);
- AssertEquals ("DataObject 4", value4, s);
+ Assert.AreEqual (value4, s, "DataObject 4");
}
[Test]
doc.LoadXml (value);
obj1.LoadXml (doc.DocumentElement);
string s = (obj1.GetXml ().OuterXml);
- AssertEquals ("DataObject Bad", value, s);
+ Assert.AreEqual (value, s, "DataObject Bad");
}
[Test]
obj.LoadXml (doc.DocumentElement);
// obj.Id = "hogehoge";
XmlElement el2 = obj.GetXml ();
- AssertEquals ("Document is kept unless setting properties", doc, el2.OwnerDocument);
+ Assert.AreEqual (doc, el2.OwnerDocument, "Document is kept unless setting properties");
}
[Test]
obj.LoadXml (doc.DocumentElement);
obj.Id = "hogehoge";
XmlElement el2 = obj.GetXml ();
- Assert ("Document is not kept when properties are set", doc != el2.OwnerDocument);
+ Assert.IsTrue (doc != el2.OwnerDocument, "Document is not kept when properties are set");
}
[Test]
obj.MimeType = "application/octet-stream";
obj.Encoding = "euc-kr";
XmlElement el1 = obj.GetXml ();
- AssertEquals ("<Object Id=\"hoge\" MimeType=\"application/octet-stream\" Encoding=\"euc-kr\" xmlns=\"http://www.w3.org/2000/09/xmldsig#\">test</Object>", el1.OuterXml);
+ Assert.AreEqual ("<Object Id=\"hoge\" MimeType=\"application/octet-stream\" Encoding=\"euc-kr\" xmlns=\"http://www.w3.org/2000/09/xmldsig#\">test</Object>", el1.OuterXml);
/* looks curious? but the element does not look to
be appended to the document.
Just commented out since it is not fixed.
- AssertEquals (String.Empty, el1.OwnerDocument.OuterXml);
+ Assert.AreEqual (String.Empty, el1.OwnerDocument.OuterXml);
*/
}
XmlElement el = new XmlDocument ().CreateElement ("foo");
d.Id = "id:1";
d.Data = el.SelectNodes (".");
- AssertEquals ("id:1", d.Id);
+ Assert.AreEqual ("id:1", d.Id);
}
[Test]
XmlElement el = new XmlDocument ().CreateElement ("foo");
DataObject d = new DataObject ("id:1", null, null, el);
d.MimeType = "text/html";
- AssertEquals ("id:1", d.Id);
+ Assert.AreEqual ("id:1", d.Id);
}
}
}
namespace MonoTests.System.Security.Cryptography.Xml {
[TestFixture]
- public class KeyInfoNameTest : Assertion {
+ public class KeyInfoNameTest {
[Test]
public void NewKeyValue ()
KeyInfoName name2 = new KeyInfoName ();
name2.LoadXml (xel);
- AssertEquals ("newKeyValue==value", newKeyValue, name1.Value);
- AssertEquals ("name1==name2", (name1.GetXml ().OuterXml), (name2.GetXml ().OuterXml));
+ Assert.AreEqual (newKeyValue, name1.Value, "newKeyValue==value");
+ Assert.AreEqual ((name1.GetXml ().OuterXml), (name2.GetXml ().OuterXml), "name1==name2");
}
[Test]
KeyInfoName name = new KeyInfoName ();
name.LoadXml (doc.DocumentElement);
- AssertEquals ("import.Name", "Mono::", name.Value);
- AssertEquals ("import.GetXml", value, name.GetXml ().OuterXml);
+ Assert.AreEqual ("Mono::", name.Value, "import.Name");
+ Assert.AreEqual (value, name.GetXml ().OuterXml, "import.GetXml");
}
[Test]
KeyInfoName name = new KeyInfoName ();
name.LoadXml (doc.DocumentElement);
- AssertEquals ("invalid.Name", "", name.Value);
- AssertEquals ("invalid.GetXml", "<KeyName xmlns=\"http://www.w3.org/2000/09/xmldsig#\"></KeyName>", (name.GetXml ().OuterXml));
+ Assert.AreEqual ("", name.Value, "invalid.Name");
+ Assert.AreEqual ("<KeyName xmlns=\"http://www.w3.org/2000/09/xmldsig#\"></KeyName>", (name.GetXml ().OuterXml), "invalid.GetXml");
}
}
}
namespace MonoTests.System.Security.Cryptography.Xml {
[TestFixture]
- public class KeyInfoNodeTest : Assertion {
+ public class KeyInfoNodeTest {
[Test]
public void NewKeyNode ()
KeyInfoNode node2 = new KeyInfoNode (node1.Value);
node2.LoadXml (xel);
- AssertEquals ("node1==node2", (node1.GetXml ().OuterXml), (node2.GetXml ().OuterXml));
+ Assert.AreEqual ((node1.GetXml ().OuterXml), (node2.GetXml ().OuterXml), "node1==node2");
}
[Test]
node1.LoadXml (doc.DocumentElement);
string s = (node1.GetXml ().OuterXml);
- AssertEquals ("Node", value, s);
+ Assert.AreEqual (value, s, "Node");
}
// well there's no invalid value - unless you read the doc ;-)
KeyInfoNode node1 = new KeyInfoNode ();
// LAMESPEC: No ArgumentNullException is thrown if value == null
node1.LoadXml (null);
- AssertNull ("Value==null", node1.Value);
+ Assert.IsNull (node1.Value, "Value==null");
}
}
}
namespace MonoTests.System.Security.Cryptography.Xml {
[TestFixture]
- public class KeyInfoRetrievalMethodTest : Assertion {
+ public class KeyInfoRetrievalMethodTest {
[Test]
public void TestNewEmptyKeyNode ()
{
KeyInfoRetrievalMethod uri1 = new KeyInfoRetrievalMethod ();
#if NET_1_0
- AssertEquals ("Empty", "<RetrievalElement xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (uri1.GetXml ().OuterXml));
+ Assert.AreEqual ("<RetrievalElement xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (uri1.GetXml ().OuterXml), "Empty");
#else
- AssertEquals ("Empty", "<RetrievalMethod xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (uri1.GetXml ().OuterXml));
+ Assert.AreEqual ("<RetrievalMethod xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (uri1.GetXml ().OuterXml), "Empty");
#endif
}
KeyInfoRetrievalMethod uri2 = new KeyInfoRetrievalMethod (uri1.Uri);
uri2.LoadXml (xel);
- AssertEquals ("uri1==uri2", (uri1.GetXml ().OuterXml), (uri2.GetXml ().OuterXml));
- AssertEquals ("uri==Uri", uri, uri1.Uri);
+ Assert.AreEqual ((uri1.GetXml ().OuterXml), (uri2.GetXml ().OuterXml), "uri1==uri2");
+ Assert.AreEqual (uri, uri1.Uri, "uri==Uri");
}
[Test]
// verify that proper XML is generated (equals to original)
string s = (uri1.GetXml ().OuterXml);
- AssertEquals ("Xml", value, s);
+ Assert.AreEqual (value, s, "Xml");
// verify that property is parsed correctly
- AssertEquals ("Uri", "http://www.go-mono.com/", uri1.Uri);
+ Assert.AreEqual ("http://www.go-mono.com/", uri1.Uri, "Uri");
}
[Test]
AssertCrypto.AssertXmlEquals ("invalid", "<RetrievalMethod xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (uri1.GetXml ().OuterXml));
#elif NET_1_1
// note that URI="" is present (unlike a empty Uri)
- AssertEquals("invalid", "<RetrievalMethod URI=\"\" xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (uri1.GetXml ().OuterXml));
+ Assert.AreEqual ("<RetrievalMethod URI=\"\" xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (uri1.GetXml ().OuterXml), "invalid");
#else
// Fx 1.0 misnamed the tag name
- AssertEquals("invalid", "<RetrievalElement URI=\"\" xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (uri1.GetXml ().OuterXml));
+ Assert.AreEqual ("<RetrievalElement URI=\"\" xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (uri1.GetXml ().OuterXml), "invalid");
#endif
}
}
namespace MonoTests.System.Security.Cryptography.Xml {
[TestFixture]
- public class KeyInfoTest : Assertion {
+ public class KeyInfoTest {
private KeyInfo info;
[Test]
public void EmptyKeyInfo ()
{
- AssertEquals ("empty", "<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (info.GetXml ().OuterXml));
- AssertEquals ("empty count", 0, info.Count);
+ Assert.AreEqual ("<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (info.GetXml ().OuterXml), "empty");
+ Assert.AreEqual (0, info.Count, "empty count");
}
[Test]
KeyInfoName name = new KeyInfoName ();
name.Value = "Mono::";
info.AddClause (name);
- AssertEquals ("name", "<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><KeyName>Mono::</KeyName></KeyInfo>", (info.GetXml ().OuterXml));
- AssertEquals ("name count", 1, info.Count);
+ Assert.AreEqual ("<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><KeyName>Mono::</KeyName></KeyInfo>", (info.GetXml ().OuterXml), "name");
+ Assert.AreEqual (1, info.Count, "name count");
}
[Test]
KeyInfoNode node = new KeyInfoNode (doc.DocumentElement);
info.AddClause (node);
- AssertEquals ("node", "<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><Test xmlns=\"\">KeyInfoNode</Test></KeyInfo>", (info.GetXml ().OuterXml));
- AssertEquals ("node count", 1, info.Count);
+ Assert.AreEqual ("<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><Test xmlns=\"\">KeyInfoNode</Test></KeyInfo>", (info.GetXml ().OuterXml), "node");
+ Assert.AreEqual (1, info.Count, "node count");
}
string xmlDSA = "<DSAKeyValue><P>rjxsMU368YOCTQejWkiuO9e/vUVwkLtq1jKiU3TtJ53hBJqjFRuTa228vZe+BH2su9RPn/vYFWfQDv6zgBYe3eNdu4Afw+Ny0FatX6dl3E77Ra6Tsd3MmLXBiGSQ1mMNd5G2XQGpbt9zsGlUaexXekeMLxIufgfZLwYp67M+2WM=</P><Q>tf0K9rMyvUrU4cIkwbCrDRhQAJk=</Q><G>S8Z+1pGCed00w6DtVcqZLKjfqlCJ7JsugEFIgSy/Vxtu9YGCMclV4ijGEbPo/jU8YOSMuD7E9M7UaopMRcmKQjoKZzoJjkgVFP48Ohxl1f08lERnButsxanx3+OstFwUGQ8XNaGg3KrIoZt1FUnfxN3RHHTvVhjzNSHxMGULGaU=</G><Y>LnrxxRGLYeV2XLtK3SYz8RQHlHFZYrtznDZyMotuRfO5uC5YODhSFyLXvb1qB3WeGtF4h3Eo4KzHgMgfN2ZMlffxFRhJgTtH3ctbL8lfQoDkjeiPPnYGhspdJxr0tyZmiy0gkjJG3vwHYrLnvZWx9Wm/unqiOlGBPNuxJ+hOeP8=</Y><J>9RhE5TycDtdEIXxS3HfxFyXYgpy81zY5lVjwD6E9JP37MWEi80BlX6ab1YPm6xYSEoqReMPP9RgGiW6DuACpgI7+8vgCr4i/7VhzModJAA56PwvTu6UMt9xxKU/fT672v8ucREkMWoc7lEey</J><Seed>HxW3N4RHWVgqDQKuGg7iJTUTiCs=</Seed><PgenCounter>Asw=</PgenCounter></DSAKeyValue>";
DSAKeyValue dsa = new DSAKeyValue (key);
info.AddClause (dsa);
AssertCrypto.AssertXmlEquals ("dsa", "<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><KeyValue xmlns=\"http://www.w3.org/2000/09/xmldsig#\">" + xmlDSA + "</KeyValue></KeyInfo>", (info.GetXml ().OuterXml));
- AssertEquals ("dsa count", 1, info.Count);
+ Assert.AreEqual (1, info.Count, "dsa count");
}
static string xmlRSA = "<RSAKeyValue><Modulus>9DC4XNdQJwMRnz5pP2a6U51MHCODRilaIoVXqUPhCUb0lJdGroeqVYT84ZyIVrcarzD7Tqs3aEOIa3rKox0N1bxQpZPqayVQeLAkjLLtzJW/ScRJx3uEDJdgT1JnM1FH0GZTinmEdCUXdLc7+Y/c/qqIkTfbwHbRZjW0bBJyExM=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";
RSAKeyValue rsa = new RSAKeyValue (key);
info.AddClause (rsa);
AssertCrypto.AssertXmlEquals ("rsa", "<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><KeyValue xmlns=\"http://www.w3.org/2000/09/xmldsig#\">" + xmlRSA + "</KeyValue></KeyInfo>", (info.GetXml ().OuterXml));
- AssertEquals ("rsa count", 1, info.Count);
+ Assert.AreEqual (1, info.Count, "rsa count");
}
[Test]
retrieval.Uri = "http://www.go-mono.org/";
info.AddClause (retrieval);
#if NET_1_0
- AssertEquals ("RetrievalMethod", "<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><RetrievalElement URI=\"http://www.go-mono.org/\" /></KeyInfo>", (info.GetXml ().OuterXml));
+ Assert.AreEqual ("<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><RetrievalElement URI=\"http://www.go-mono.org/\" /></KeyInfo>", (info.GetXml ().OuterXml), "RetrievalMethod");
#else
- AssertEquals ("RetrievalMethod", "<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><RetrievalMethod URI=\"http://www.go-mono.org/\" /></KeyInfo>", (info.GetXml ().OuterXml));
+ Assert.AreEqual ("<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><RetrievalMethod URI=\"http://www.go-mono.org/\" /></KeyInfo>", (info.GetXml ().OuterXml), "RetrievalMethod");
#endif
- AssertEquals ("RetrievalMethod count", 1, info.Count);
+ Assert.AreEqual (1, info.Count, "RetrievalMethod count");
}
static byte[] cert = { 0x30,0x82,0x02,0x1D,0x30,0x82,0x01,0x86,0x02,0x01,0x14,0x30,0x0D,0x06,0x09,0x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,0x01,0x04,0x05,0x00,0x30,0x58,0x31,0x0B,0x30,0x09,0x06,0x03,0x55,0x04,0x06,0x13,0x02,0x43,0x41,0x31,0x1F,0x30,0x1D,0x06,0x03,0x55,0x04,0x03,0x13,0x16,0x4B,0x65,0x79,0x77,0x69,0x74,0x6E,0x65,0x73,0x73,0x20,0x43,0x61,0x6E,0x61,0x64,0x61,0x20,0x49,0x6E,0x63,0x2E,0x31,0x28,0x30,0x26,0x06,0x0A,0x2B,0x06,0x01,0x04,0x01,0x2A,0x02,0x0B,0x02,0x01,0x13,0x18,0x6B,0x65,0x79,0x77,0x69,0x74,0x6E,0x65,0x73,
KeyInfoX509Data x509data = new KeyInfoX509Data (x509);
info.AddClause (x509data);
AssertCrypto.AssertXmlEquals ("X509Data", "<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><X509Data xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><X509Certificate>MIICHTCCAYYCARQwDQYJKoZIhvcNAQEEBQAwWDELMAkGA1UEBhMCQ0ExHzAdBgNVBAMTFktleXdpdG5lc3MgQ2FuYWRhIEluYy4xKDAmBgorBgEEASoCCwIBExhrZXl3aXRuZXNzQGtleXdpdG5lc3MuY2EwHhcNOTYwNTA3MDAwMDAwWhcNOTkwNTA3MDAwMDAwWjBYMQswCQYDVQQGEwJDQTEfMB0GA1UEAxMWS2V5d2l0bmVzcyBDYW5hZGEgSW5jLjEoMCYGCisGAQQBKgILAgETGGtleXdpdG5lc3NAa2V5d2l0bmVzcy5jYTCBnTANBgkqhkiG9w0BAQEFAAOBiwAwgYcCgYEAzSP6KuHtmPTp0JM+13qAAkzMwQKvXLYff/pXQm8w0SDFtSEHQCyphsLzZISuPYUu7YW9VLAYKO9q+BvnCxYfkyVPx/iOw7nKmIQOVdAv73h3xXIoX2C/GSvRcqK32D/glzRaAb0EnMh4Rc2TjRXydhARq7hbLp5S3YE+nGTIKZMCAQMwDQYJKoZIhvcNAQEEBQADgYEAMho1ur9DJ9a01Lh25eObTWzAhsl3NbprFi0TRkqwMlOhW1rpmeIMhogXTg3+gqxOR+/7/zms7jXI+lI3CkmtWa3iiqkcxl8f+G9zfs2gMegMvvVN2bKrihK2MHhoEXwN8UlNo/2y6f8d8JH6VIX/M5Dowb+km6RiRr1hElmYQYk=</X509Certificate></X509Data></KeyInfo>", (info.GetXml ().OuterXml));
- AssertEquals ("X509Data count", 1, info.Count);
+ Assert.AreEqual (1, info.Count, "X509Data count");
}
[Test]
s += "<X509Data xmlns=\"http://www.w3.org/2000/09/xmldsig#\">";
s += "<X509Certificate>MIICHTCCAYYCARQwDQYJKoZIhvcNAQEEBQAwWDELMAkGA1UEBhMCQ0ExHzAdBgNVBAMTFktleXdpdG5lc3MgQ2FuYWRhIEluYy4xKDAmBgorBgEEASoCCwIBExhrZXl3aXRuZXNzQGtleXdpdG5lc3MuY2EwHhcNOTYwNTA3MDAwMDAwWhcNOTkwNTA3MDAwMDAwWjBYMQswCQYDVQQGEwJDQTEfMB0GA1UEAxMWS2V5d2l0bmVzcyBDYW5hZGEgSW5jLjEoMCYGCisGAQQBKgILAgETGGtleXdpdG5lc3NAa2V5d2l0bmVzcy5jYTCBnTANBgkqhkiG9w0BAQEFAAOBiwAwgYcCgYEAzSP6KuHtmPTp0JM+13qAAkzMwQKvXLYff/pXQm8w0SDFtSEHQCyphsLzZISuPYUu7YW9VLAYKO9q+BvnCxYfkyVPx/iOw7nKmIQOVdAv73h3xXIoX2C/GSvRcqK32D/glzRaAb0EnMh4Rc2TjRXydhARq7hbLp5S3YE+nGTIKZMCAQMwDQYJKoZIhvcNAQEEBQADgYEAMho1ur9DJ9a01Lh25eObTWzAhsl3NbprFi0TRkqwMlOhW1rpmeIMhogXTg3+gqxOR+/7/zms7jXI+lI3CkmtWa3iiqkcxl8f+G9zfs2gMegMvvVN2bKrihK2MHhoEXwN8UlNo/2y6f8d8JH6VIX/M5Dowb+km6RiRr1hElmYQYk=</X509Certificate></X509Data></KeyInfo>";
AssertCrypto.AssertXmlEquals ("Complex", s, (info.GetXml ().OuterXml));
- AssertEquals ("RetrievalMethod count", 5, info.Count);
+ Assert.AreEqual (5, info.Count, "RetrievalMethod count");
}
[Test]
info.LoadXml (doc.DocumentElement);
AssertCrypto.AssertXmlEquals ("Import", value, (info.GetXml ().OuterXml));
- AssertEquals ("Import count", 5, info.Count);
+ Assert.AreEqual (5, info.Count, "Import count");
}
[Test]
[ExpectedException (typeof (NullReferenceException))]
public void NullClause ()
{
- AssertEquals ("empty count", 0, info.Count);
+ Assert.AreEqual (0, info.Count, "empty count");
// null is accepted...
info.AddClause (null);
- AssertEquals ("null count", 1, info.Count);
+ Assert.AreEqual (1, info.Count, "null count");
// but can't get XML out if it!
XmlElement xel = info.GetXml ();
}
doc.LoadXml (bad);
info.LoadXml (doc.DocumentElement);
// LAMESPEC: no expection but Xml isn't loaded
- AssertEquals ("invalid", "<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (info.GetXml ().OuterXml));
- AssertEquals ("invalid count", 0, info.Count);
+ Assert.AreEqual ("<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", (info.GetXml ().OuterXml), "invalid");
+ Assert.AreEqual (0, info.Count, "invalid count");
}
}
}
namespace MonoTests.System.Security.Cryptography.Xml {
[TestFixture]
- public class RSAKeyValueTest : Assertion {
+ public class RSAKeyValueTest {
[Test]
public void GeneratedKey ()
{
RSAKeyValue rsa1 = new RSAKeyValue ();
- AssertNotNull ("Key", rsa1.Key);
+ Assert.IsNotNull (rsa1.Key, "Key");
XmlElement xmlkey = rsa1.GetXml ();
RSAKeyValue rsa2 = new RSAKeyValue ();
rsa2.LoadXml (xmlkey);
- Assert ("rsa1==rsa2", (rsa1.GetXml ().OuterXml) == (rsa2.GetXml ().OuterXml));
+ Assert.IsTrue ((rsa1.GetXml ().OuterXml) == (rsa2.GetXml ().OuterXml), "rsa1==rsa2");
RSA key = rsa1.Key;
RSAKeyValue rsa3 = new RSAKeyValue (key);
- Assert ("rsa3==rsa1", (rsa3.GetXml ().OuterXml) == (rsa1.GetXml ().OuterXml));
- Assert ("rsa3==rsa2", (rsa3.GetXml ().OuterXml) == (rsa2.GetXml ().OuterXml));
+ Assert.IsTrue ((rsa3.GetXml ().OuterXml) == (rsa1.GetXml ().OuterXml), "rsa3==rsa1");
+ Assert.IsTrue ((rsa3.GetXml ().OuterXml) == (rsa2.GetXml ().OuterXml), "rsa3==rsa2");
}
[Test]
rsa1.LoadXml (doc.DocumentElement);
string s = (rsa1.GetXml ().OuterXml);
- AssertEquals ("RSA Key", rsaKey, s);
+ Assert.AreEqual (rsaKey, s, "RSA Key");
}
[Test]
namespace MonoTests.System.Security.Cryptography.Xml {
[TestFixture]
- public class ReferenceTest : Assertion {
+ public class ReferenceTest {
protected Reference reference;
[Test]
public void Properties ()
{
- AssertNull ("Uri (null)", reference.Uri);
- AssertNotNull ("TransformChain", reference.TransformChain);
- AssertEquals ("ToString()", "System.Security.Cryptography.Xml.Reference", reference.ToString ());
+ Assert.IsNull (reference.Uri, "Uri (null)");
+ Assert.IsNotNull (reference.TransformChain, "TransformChain");
+ Assert.AreEqual ("System.Security.Cryptography.Xml.Reference", reference.ToString (), "ToString()");
// test uri constructor
string uri = "uri";
reference = new Reference (uri);
- AssertEquals ("DigestMethod", "http://www.w3.org/2000/09/xmldsig#sha1", reference.DigestMethod);
- AssertNull ("DigestValue", reference.DigestValue);
- AssertNull ("Id", reference.Id);
- AssertNull ("Type", reference.Type);
- AssertEquals ("Uri", uri, reference.Uri);
+ Assert.AreEqual ("http://www.w3.org/2000/09/xmldsig#sha1", reference.DigestMethod, "DigestMethod");
+ Assert.IsNull (reference.DigestValue, "DigestValue");
+ Assert.IsNull (reference.Id, "Id");
+ Assert.IsNull (reference.Type, "Type");
+ Assert.AreEqual (uri, reference.Uri, "Uri");
}
[Test]
XmlDocument doc = new XmlDocument ();
doc.LoadXml (test);
reference.LoadXml (doc.DocumentElement);
- AssertEquals ("Load-Xml", test, (reference.GetXml().OuterXml));
- AssertEquals ("Load-URI", "#MyObjectId", reference.Uri);
+ Assert.AreEqual (test, (reference.GetXml().OuterXml), "Load-Xml");
+ Assert.AreEqual ("#MyObjectId", reference.Uri, "Load-URI");
byte[] hash = { 0xFD, 0x5B, 0xEA, 0xEA, 0xC5, 0xC4, 0x55, 0xBB, 0x59, 0x0B, 0xC1, 0xB0, 0x36, 0xD2, 0xD0, 0x9C, 0x63, 0xB2, 0xFD, 0x52 };
AssertCrypto.AssertEquals("Load-Digest", hash, reference.DigestValue);
- AssertEquals ("Load-#Transform", 0, reference.TransformChain.Count);
+ Assert.AreEqual (0, reference.TransformChain.Count, "Load-#Transform");
}
[Test]
XmlDocument doc = new XmlDocument ();
doc.LoadXml (test);
reference.LoadXml (doc.DocumentElement);
- AssertEquals ("Load-Base64", test, (reference.GetXml().OuterXml));
- AssertEquals ("Load-#Transform", 1, reference.TransformChain.Count);
+ Assert.AreEqual (test, (reference.GetXml().OuterXml), "Load-Base64");
+ Assert.AreEqual (1, reference.TransformChain.Count, "Load-#Transform");
}
[Test]
XmlDocument doc = new XmlDocument ();
doc.LoadXml (test);
reference.LoadXml (doc.DocumentElement);
- AssertEquals ("Load-C14N", test, (reference.GetXml().OuterXml));
- AssertEquals ("Load-#Transform", 1, reference.TransformChain.Count);
+ Assert.AreEqual (test, (reference.GetXml().OuterXml), "Load-C14N");
+ Assert.AreEqual (1, reference.TransformChain.Count, "Load-#Transform");
}
[Test]
XmlDocument doc = new XmlDocument ();
doc.LoadXml (test);
reference.LoadXml (doc.DocumentElement);
- AssertEquals ("Load-C14NWithComments", test, (reference.GetXml().OuterXml));
- AssertEquals ("Load-#Transform", 1, reference.TransformChain.Count);
+ Assert.AreEqual (test, (reference.GetXml().OuterXml), "Load-C14NWithComments");
+ Assert.AreEqual (1, reference.TransformChain.Count, "Load-#Transform");
}
[Test]
XmlDocument doc = new XmlDocument ();
doc.LoadXml (test);
reference.LoadXml (doc.DocumentElement);
- AssertEquals ("Load-Enveloped", test, (reference.GetXml().OuterXml));
- AssertEquals ("Load-#Transform", 1, reference.TransformChain.Count);
+ Assert.AreEqual (test, (reference.GetXml().OuterXml), "Load-Enveloped");
+ Assert.AreEqual (1, reference.TransformChain.Count, "Load-#Transform");
}
[Test]
doc.LoadXml (test1);
reference.LoadXml (doc.DocumentElement);
string result = (reference.GetXml().OuterXml);
- Assert (result, ((test1 == result) || (test2 == result)));
- AssertEquals ("Load-#Transform", 1, reference.TransformChain.Count);
+ Assert.IsTrue (((test1 == result) || (test2 == result)), result);
+ Assert.AreEqual (1, reference.TransformChain.Count, "Load-#Transform");
}
[Test]
doc.LoadXml (test);
reference.LoadXml (doc.DocumentElement);
string result = reference.GetXml().OuterXml;
- AssertEquals (result, test, result);
- AssertEquals ("Load-#Transform", 1, reference.TransformChain.Count);
+ Assert.AreEqual (test, result, result);
+ Assert.AreEqual (1, reference.TransformChain.Count, "Load-#Transform");
}
[Test]
doc.LoadXml (test1);
reference.LoadXml (doc.DocumentElement);
string result = reference.GetXml().OuterXml;
- Assert (result, ((result == test1) || (result == test2)));
- AssertEquals ("Load-#Transform", 6, reference.TransformChain.Count);
+ Assert.IsTrue (((result == test1) || (result == test2)), result);
+ Assert.AreEqual (6, reference.TransformChain.Count, "Load-#Transform");
}
[Test]
reference.DigestValue = hash;
XmlElement xel = reference.GetXml ();
// this is the minimal Reference (DigestValue)!
- AssertNotNull ("GetXml", xel);
+ Assert.IsNotNull (xel, "GetXml");
reference.AddTransform (new XmlDsigBase64Transform ());
reference.AddTransform (new XmlDsigC14NTransform ());
// Mono's result (xml is equivalent but not identical)
string test2 = test1.Replace ("<XPath></XPath>", "<XPath xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />");
string result = reference.GetXml().OuterXml;
- Assert (result, ((result == test1) || (result == test2)));
+ Assert.IsTrue (((result == test1) || (result == test2)), result);
// however this value cannot be loaded as it's missing some transform (xslt) parameters
// can we add them again ?
reference.AddTransform (new XmlDsigXsltTransform ());
// seems so ;-)
- AssertEquals ("# Transforms", 12, reference.TransformChain.Count);
+ Assert.AreEqual (12, reference.TransformChain.Count, "# Transforms");
}
[Test]
{
// null DigestMethod -> "" DigestMethod !!!
reference.DigestMethod = null;
- AssertNull ("DigestMethod null", reference.DigestMethod);
+ Assert.IsNull (reference.DigestMethod, "DigestMethod null");
}
[Test]
Reference r = new Reference ();
r.LoadXml (org);
XmlElement el = r.GetXml ();
- AssertEquals (doc, el.OwnerDocument);
- AssertEquals (org, el);
- AssertEquals (result, el.OuterXml);
+ Assert.AreEqual (doc, el.OwnerDocument);
+ Assert.AreEqual (org, el);
+ Assert.AreEqual (result, el.OuterXml);
}
}
}
namespace MonoTests.System.Security.Cryptography.Xml {
[TestFixture]
- public class SignatureTest : Assertion {
+ public class SignatureTest {
protected Signature signature;
namespace MonoTests.System.Security.Cryptography.Xml {
[TestFixture]
- public class SignedInfoTest : Assertion {
+ public class SignedInfoTest {
protected SignedInfo info;
[Test]
public void Empty ()
{
- AssertEquals ("CanonicalizationMethod", "http://www.w3.org/TR/2001/REC-xml-c14n-20010315", info.CanonicalizationMethod);
- AssertNull ("Id", info.Id);
- AssertNotNull ("References", info.References);
- AssertEquals ("References.Count", 0, info.References.Count);
- AssertNull ("SignatureLength", info.SignatureLength);
- AssertNull ("SignatureMethod", info.SignatureMethod);
- AssertEquals ("ToString()", "System.Security.Cryptography.Xml.SignedInfo", info.ToString ());
+ Assert.AreEqual ("http://www.w3.org/TR/2001/REC-xml-c14n-20010315", info.CanonicalizationMethod, "CanonicalizationMethod");
+ Assert.IsNull (info.Id, "Id");
+ Assert.IsNotNull (info.References, "References");
+ Assert.AreEqual (0, info.References.Count, "References.Count");
+ Assert.IsNull (info.SignatureLength, "SignatureLength");
+ Assert.IsNull (info.SignatureMethod, "SignatureMethod");
+ Assert.AreEqual ("System.Security.Cryptography.Xml.SignedInfo", info.ToString (), "ToString()");
}
[Test]
public void Properties ()
{
info.CanonicalizationMethod = "http://www.go-mono.com/";
- AssertEquals ("CanonicalizationMethod", "http://www.go-mono.com/", info.CanonicalizationMethod);
+ Assert.AreEqual ("http://www.go-mono.com/", info.CanonicalizationMethod, "CanonicalizationMethod");
info.Id = "Mono::";
- AssertEquals ("Id", "Mono::", info.Id);
+ Assert.AreEqual ("Mono::", info.Id, "Id");
}
[Test]
r1.Uri = "http://www.go-mono.com/";
r1.AddTransform (new XmlDsigBase64Transform ());
info.AddReference (r1);
- AssertEquals ("References.Count 1", 1, info.References.Count);
+ Assert.AreEqual (1, info.References.Count, "References.Count 1");
Reference r2 = new Reference ("http://www.motus.com/");
r2.AddTransform (new XmlDsigBase64Transform ());
info.AddReference (r2);
- AssertEquals ("References.Count 2", 2, info.References.Count);
+ Assert.AreEqual (2, info.References.Count, "References.Count 2");
info.SignatureMethod = "http://www.w3.org/2000/09/xmldsig#dsa-sha1";
}
XmlDocument doc = new XmlDocument ();
doc.LoadXml (xml);
info.LoadXml (doc.DocumentElement);
- AssertEquals ("LoadXml", xml, (info.GetXml ().OuterXml));
- AssertEquals ("LoadXml-C14N", "http://www.w3.org/TR/2001/REC-xml-c14n-20010315", info.CanonicalizationMethod);
- AssertEquals ("LoadXml-Algo", "http://www.w3.org/2000/09/xmldsig#rsa-sha1", info.SignatureMethod);
- AssertEquals ("LoadXml-Ref1", 1, info.References.Count);
+ Assert.AreEqual (xml, (info.GetXml ().OuterXml), "LoadXml");
+ Assert.AreEqual ("http://www.w3.org/TR/2001/REC-xml-c14n-20010315", info.CanonicalizationMethod, "LoadXml-C14N");
+ Assert.AreEqual ("http://www.w3.org/2000/09/xmldsig#rsa-sha1", info.SignatureMethod, "LoadXml-Algo");
+ Assert.AreEqual (1, info.References.Count, "LoadXml-Ref1");
}
// there are many (documented) not supported methods in SignedInfo
SignedInfo sig = new SignedInfo ();
sig.LoadXml ((XmlElement) doc.SelectSingleNode ("//*[local-name()='SignedInfo']"));
XmlElement el = sig.GetXml ();
- AssertEquals ("#GetXmlWOSetProperty.document", doc, el.OwnerDocument);
- AssertEquals ("#GetXmlWOSetProperty.outerxml", result, el.OuterXml);
+ Assert.AreEqual (doc, el.OwnerDocument, "#GetXmlWOSetProperty.document");
+ Assert.AreEqual (result, el.OuterXml, "#GetXmlWOSetProperty.outerxml");
}
[Test]
sig.LoadXml ((XmlElement) doc.SelectSingleNode ("//*[local-name()='SignedInfo']"));
sig.CanonicalizationMethod = "urn:foo";
XmlElement el = sig.GetXml ();
- Assert ("#GetXmlWithSetProperty.document", doc != el.OwnerDocument);
+ Assert.IsTrue (doc != el.OwnerDocument, "#GetXmlWithSetProperty.document");
}
[Test] // never fails
}
[TestFixture]
- public class SignedXmlTest : Assertion {
+ public class SignedXmlTest {
private const string signature = "<Signature xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><SignedInfo><CanonicalizationMethod Algorithm=\"http://www.w3.org/TR/2001/REC-xml-c14n-20010315\" /><SignatureMethod Algorithm=\"http://www.w3.org/2000/09/xmldsig#rsa-sha1\" /><Reference URI=\"#MyObjectId\"><DigestMethod Algorithm=\"http://www.w3.org/2000/09/xmldsig#sha1\" /><DigestValue>CTnnhjxUQHJmD+t1MjVXrOW+MCA=</DigestValue></Reference></SignedInfo><SignatureValue>dbFt6Zw3vR+Xh7LbM/vuifyFA7gPh/NlDM2Glz/SJBsveISieuTBpZlk/zavAeuXR/Nu0Ztt4OP4tCOg09a2RNlrTP0dhkeEfL1jTzpnVaLHuQbCiwOWCgbRif7Xt7N12FuiHYb3BltP/YyXS4E12NxlGlqnDiFA1v/mkK5+C1o=</SignatureValue><KeyInfo><KeyValue xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><RSAKeyValue><Modulus>hEfTJNa2idz2u+fSYDDG4Lx/xuk4aBbvOPVNqgc1l9Y8t7Pt+ZyF+kkF3uUl8Y0700BFGAsprnhwrWENK+PGdtvM5796ZKxCCa0ooKkofiT4355HqK26hpV8dvj38vq/rkJe1jHZgkTKa+c/0vjcYZOI/RT/IZv9JfXxVWLuLxk=</Modulus><Exponent>EQ==</Exponent></RSAKeyValue></KeyValue></KeyInfo><Object Id=\"MyObjectId\" xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><ObjectListTag xmlns=\"\" /></Object></Signature>";
[Test]
public void StaticValues ()
{
- AssertEquals ("XmlDsigCanonicalizationUrl", "http://www.w3.org/TR/2001/REC-xml-c14n-20010315", SignedXml.XmlDsigCanonicalizationUrl);
- AssertEquals ("XmlDsigCanonicalizationWithCommentsUrl", "http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments", SignedXml.XmlDsigCanonicalizationWithCommentsUrl);
- AssertEquals ("XmlDsigDSAUrl", "http://www.w3.org/2000/09/xmldsig#dsa-sha1", SignedXml.XmlDsigDSAUrl);
- AssertEquals ("XmlDsigHMACSHA1Url", "http://www.w3.org/2000/09/xmldsig#hmac-sha1", SignedXml.XmlDsigHMACSHA1Url);
- AssertEquals ("XmlDsigMinimalCanonicalizationUrl", "http://www.w3.org/2000/09/xmldsig#minimal", SignedXml.XmlDsigMinimalCanonicalizationUrl);
- AssertEquals ("XmlDsigNamespaceUrl", "http://www.w3.org/2000/09/xmldsig#", SignedXml.XmlDsigNamespaceUrl);
- AssertEquals ("XmlDsigRSASHA1Url", "http://www.w3.org/2000/09/xmldsig#rsa-sha1", SignedXml.XmlDsigRSASHA1Url);
- AssertEquals ("XmlDsigSHA1Url", "http://www.w3.org/2000/09/xmldsig#sha1", SignedXml.XmlDsigSHA1Url);
+ Assert.AreEqual ("http://www.w3.org/TR/2001/REC-xml-c14n-20010315", SignedXml.XmlDsigCanonicalizationUrl, "XmlDsigCanonicalizationUrl");
+ Assert.AreEqual ("http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments", SignedXml.XmlDsigCanonicalizationWithCommentsUrl, "XmlDsigCanonicalizationWithCommentsUrl");
+ Assert.AreEqual ("http://www.w3.org/2000/09/xmldsig#dsa-sha1", SignedXml.XmlDsigDSAUrl, "XmlDsigDSAUrl");
+ Assert.AreEqual ("http://www.w3.org/2000/09/xmldsig#hmac-sha1", SignedXml.XmlDsigHMACSHA1Url, "XmlDsigHMACSHA1Url");
+ Assert.AreEqual ("http://www.w3.org/2000/09/xmldsig#minimal", SignedXml.XmlDsigMinimalCanonicalizationUrl, "XmlDsigMinimalCanonicalizationUrl");
+ Assert.AreEqual ("http://www.w3.org/2000/09/xmldsig#", SignedXml.XmlDsigNamespaceUrl, "XmlDsigNamespaceUrl");
+ Assert.AreEqual ("http://www.w3.org/2000/09/xmldsig#rsa-sha1", SignedXml.XmlDsigRSASHA1Url, "XmlDsigRSASHA1Url");
+ Assert.AreEqual ("http://www.w3.org/2000/09/xmldsig#sha1", SignedXml.XmlDsigSHA1Url, "XmlDsigSHA1Url");
}
[Test]
SignedXml sx = new SignedXml (doc);
sx.LoadXml (xel);
- Assert ("CheckSignature", sx.CheckSignature ());
+ Assert.IsTrue (sx.CheckSignature (), "CheckSignature");
}
[Test]
SignedXml sx = new SignedXml (doc);
sx.LoadXml (doc.DocumentElement);
- Assert ("CheckSignature", sx.CheckSignature ());
+ Assert.IsTrue (sx.CheckSignature (), "CheckSignature");
}
[Test]
SignedXml sx = new SignedXml (doc.DocumentElement);
sx.LoadXml (xel);
- Assert ("CheckSignature", sx.CheckSignature ());
+ Assert.IsTrue (sx.CheckSignature (), "CheckSignature");
}
[Test]
XmlElement xel = (XmlElement) xnl [0];
SignedXml sx = new SignedXml (doc.DocumentElement);
- Assert ("!CheckSignature", !sx.CheckSignature ());
+ Assert.IsTrue (!sx.CheckSignature (), "!CheckSignature");
// SignedXml (XmlElement) != SignedXml () + LoadXml (XmlElement)
}
keyInfo.AddClause (new RSAKeyValue (key));
signedXml.KeyInfo = keyInfo;
- AssertNotNull ("SignatureMethod", signedXml.SignatureMethod);
+ Assert.IsNotNull (signedXml.SignatureMethod, "SignatureMethod");
// Compute the signature - causes unsupported algorithm by the key.
signedXml.ComputeSignature ();
}
keyInfo.AddClause (new RSAKeyValue (key));
signedXml.KeyInfo = keyInfo;
- AssertEquals ("KeyInfo", 1, signedXml.KeyInfo.Count);
- AssertNull ("SignatureLength", signedXml.SignatureLength);
- AssertNull ("SignatureMethod", signedXml.SignatureMethod);
- AssertNull ("SignatureValue", signedXml.SignatureValue);
- AssertNull ("SigningKeyName", signedXml.SigningKeyName);
+ Assert.AreEqual (1, signedXml.KeyInfo.Count, "KeyInfo");
+ Assert.IsNull (signedXml.SignatureLength, "SignatureLength");
+ Assert.IsNull (signedXml.SignatureMethod, "SignatureMethod");
+ Assert.IsNull (signedXml.SignatureValue, "SignatureValue");
+ Assert.IsNull (signedXml.SigningKeyName, "SigningKeyName");
// Compute the signature.
signedXml.ComputeSignature ();
- AssertNull ("SigningKeyName", signedXml.SigningKeyName);
- AssertEquals ("SignatureMethod", SignedXml.XmlDsigRSASHA1Url, signedXml.SignatureMethod);
- AssertEquals ("SignatureValue", 128, signedXml.SignatureValue.Length);
- AssertNull ("SigningKeyName", signedXml.SigningKeyName);
+ Assert.IsNull (signedXml.SigningKeyName, "SigningKeyName");
+ Assert.AreEqual (SignedXml.XmlDsigRSASHA1Url, signedXml.SignatureMethod, "SignatureMethod");
+ Assert.AreEqual (128, signedXml.SignatureValue.Length, "SignatureValue");
+ Assert.IsNull (signedXml.SigningKeyName, "SigningKeyName");
// Get the XML representation of the signature.
XmlElement xmlSignature = signedXml.GetXml ();
vrfy.LoadXml (xmlSignature);
// assert that we can verify our own signature
- Assert ("RSA-Compute/Verify", vrfy.CheckSignature ());
+ Assert.IsTrue (vrfy.CheckSignature (), "RSA-Compute/Verify");
}
[Test]
keyInfo.AddClause (new DSAKeyValue (key));
signedXml.KeyInfo = keyInfo;
- AssertEquals ("KeyInfo", 1, signedXml.KeyInfo.Count);
- AssertNull ("SignatureLength", signedXml.SignatureLength);
- AssertNull ("SignatureMethod", signedXml.SignatureMethod);
- AssertNull ("SignatureValue", signedXml.SignatureValue);
- AssertNull ("SigningKeyName", signedXml.SigningKeyName);
+ Assert.AreEqual (1, signedXml.KeyInfo.Count, "KeyInfo");
+ Assert.IsNull (signedXml.SignatureLength, "SignatureLength");
+ Assert.IsNull (signedXml.SignatureMethod, "SignatureMethod");
+ Assert.IsNull (signedXml.SignatureValue, "SignatureValue");
+ Assert.IsNull (signedXml.SigningKeyName, "SigningKeyName");
// Compute the signature.
signedXml.ComputeSignature ();
- AssertNull ("SignatureLength", signedXml.SignatureLength);
- AssertEquals ("SignatureMethod", SignedXml.XmlDsigDSAUrl, signedXml.SignatureMethod);
- AssertEquals ("SignatureValue", 40, signedXml.SignatureValue.Length);
- AssertNull ("SigningKeyName", signedXml.SigningKeyName);
+ Assert.IsNull (signedXml.SignatureLength, "SignatureLength");
+ Assert.AreEqual (SignedXml.XmlDsigDSAUrl, signedXml.SignatureMethod, "SignatureMethod");
+ Assert.AreEqual (40, signedXml.SignatureValue.Length, "SignatureValue");
+ Assert.IsNull (signedXml.SigningKeyName, "SigningKeyName");
// Get the XML representation of the signature.
XmlElement xmlSignature = signedXml.GetXml ();
vrfy.LoadXml (xmlSignature);
// assert that we can verify our own signature
- Assert ("DSA-Compute/Verify", vrfy.CheckSignature ());
+ Assert.IsTrue (vrfy.CheckSignature (), "DSA-Compute/Verify");
}
[Test]
byte[] secretkey = Encoding.Default.GetBytes ("password");
HMACSHA1 hmac = new HMACSHA1 (secretkey);
#if NET_2_0
- AssertEquals ("KeyInfo", 0, signedXml.KeyInfo.Count);
+ Assert.AreEqual (0, signedXml.KeyInfo.Count, "KeyInfo");
#else
- AssertNull ("KeyInfo", signedXml.KeyInfo);
+ Assert.IsNull (signedXml.KeyInfo, "KeyInfo");
#endif
- AssertNull ("SignatureLength", signedXml.SignatureLength);
- AssertNull ("SignatureMethod", signedXml.SignatureMethod);
- AssertNull ("SignatureValue", signedXml.SignatureValue);
- AssertNull ("SigningKeyName", signedXml.SigningKeyName);
+ Assert.IsNull (signedXml.SignatureLength, "SignatureLength");
+ Assert.IsNull (signedXml.SignatureMethod, "SignatureMethod");
+ Assert.IsNull (signedXml.SignatureValue, "SignatureValue");
+ Assert.IsNull (signedXml.SigningKeyName, "SigningKeyName");
signedXml.ComputeSignature (hmac);
#if NET_2_0
- AssertEquals ("KeyInfo", 0, signedXml.KeyInfo.Count);
+ Assert.AreEqual (0, signedXml.KeyInfo.Count, "KeyInfo");
#else
- AssertNull ("KeyInfo", signedXml.KeyInfo);
+ Assert.IsNull (signedXml.KeyInfo, "KeyInfo");
#endif
- AssertNull ("SignatureLength", signedXml.SignatureLength);
- AssertEquals ("SignatureMethod", SignedXml.XmlDsigHMACSHA1Url, signedXml.SignatureMethod);
- AssertEquals ("SignatureValue", 20, signedXml.SignatureValue.Length);
- AssertNull ("SigningKeyName", signedXml.SigningKeyName);
+ Assert.IsNull (signedXml.SignatureLength, "SignatureLength");
+ Assert.AreEqual (SignedXml.XmlDsigHMACSHA1Url, signedXml.SignatureMethod, "SignatureMethod");
+ Assert.AreEqual (20, signedXml.SignatureValue.Length, "SignatureValue");
+ Assert.IsNull (signedXml.SigningKeyName, "SigningKeyName");
// Get the XML representation of the signature.
XmlElement xmlSignature = signedXml.GetXml ();
vrfy.LoadXml (xmlSignature);
// assert that we can verify our own signature
- Assert ("HMACSHA1-Compute/Verify", vrfy.CheckSignature (hmac));
+ Assert.IsTrue (vrfy.CheckSignature (hmac), "HMACSHA1-Compute/Verify");
}
[Test]
SignedXml v1 = new SignedXml ();
v1.LoadXml (doc.DocumentElement);
- Assert ("RSA-CheckSignature()", v1.CheckSignature ());
+ Assert.IsTrue (v1.CheckSignature (), "RSA-CheckSignature()");
SignedXml v2 = new SignedXml ();
v2.LoadXml (doc.DocumentElement);
AsymmetricAlgorithm key = null;
bool vrfy = v2.CheckSignatureReturningKey (out key);
- Assert ("RSA-CheckSignatureReturningKey()", vrfy);
+ Assert.IsTrue (vrfy, "RSA-CheckSignatureReturningKey()");
SignedXml v3 = new SignedXml ();
v3.LoadXml (doc.DocumentElement);
- Assert ("RSA-CheckSignature(key)", v3.CheckSignature (key));
+ Assert.IsTrue (v3.CheckSignature (key), "RSA-CheckSignature(key)");
}
// Using empty constructor
SignedXml v1 = new SignedXml ();
v1.LoadXml (doc.DocumentElement);
- Assert ("DSA-CheckSignature()", v1.CheckSignature ());
+ Assert.IsTrue (v1.CheckSignature (), "DSA-CheckSignature()");
SignedXml v2 = new SignedXml ();
v2.LoadXml (doc.DocumentElement);
AsymmetricAlgorithm key = null;
bool vrfy = v2.CheckSignatureReturningKey (out key);
- Assert ("DSA-CheckSignatureReturningKey()", vrfy);
+ Assert.IsTrue (vrfy, "DSA-CheckSignatureReturningKey()");
SignedXml v3 = new SignedXml ();
v3.LoadXml (doc.DocumentElement);
- Assert ("DSA-CheckSignature(key)", v3.CheckSignature (key));
+ Assert.IsTrue (v3.CheckSignature (key), "DSA-CheckSignature(key)");
}
[Test]
byte[] secretkey = Encoding.Default.GetBytes ("password");
HMACSHA1 hmac = new HMACSHA1 (secretkey);
- Assert ("HMACSHA1-CheckSignature(key)", v1.CheckSignature (hmac));
+ Assert.IsTrue (v1.CheckSignature (hmac), "HMACSHA1-CheckSignature(key)");
}
[Test]
SignedXml v1 = new SignedXml ();
v1.LoadXml (doc.DocumentElement);
- Assert ("CheckSignature", v1.CheckSignature ());
+ Assert.IsTrue (v1.CheckSignature (), "CheckSignature");
XmlElement xel = v1.GetIdElement (doc, "MyObjectId");
- Assert ("GetIdElement", xel.InnerXml.StartsWith ("<ObjectListTag"));
+ Assert.IsTrue (xel.InnerXml.StartsWith ("<ObjectListTag"), "GetIdElement");
}
[Test]
sxe.LoadXml (doc.DocumentElement);
AsymmetricAlgorithm aa1 = sxe.PublicGetPublicKey ();
- Assert ("First Public Key is RSA", (aa1 is RSA));
+ Assert.IsTrue ((aa1 is RSA), "First Public Key is RSA");
AsymmetricAlgorithm aa2 = sxe.PublicGetPublicKey ();
- AssertNull ("Second Public Key is null", aa2);
+ Assert.IsNull (aa2, "Second Public Key is null");
}
#if NET_2_0
[Test]
public void SigningKeyName ()
{
SignedXmlEx sxe = new SignedXmlEx ();
- AssertNull ("SigningKeyName", sxe.SigningKeyName);
+ Assert.IsNull (sxe.SigningKeyName, "SigningKeyName");
sxe.SigningKeyName = "mono";
- AssertEquals ("SigningKeyName", "mono", sxe.SigningKeyName);
+ Assert.AreEqual ("mono", sxe.SigningKeyName, "SigningKeyName");
}
[Test]
// empty keyinfo passes...
sx = new SignedXml ();
sx.KeyInfo = new KeyInfo ();
- Assert (!sx.CheckSignature ());
+ Assert.IsTrue (!sx.CheckSignature ());
// with empty KeyInfoName
kic = new KeyInfoName ();
ki = new KeyInfo ();
ki.AddClause (kic);
sx.KeyInfo = ki;
- Assert (!sx.CheckSignature ());
+ Assert.IsTrue (!sx.CheckSignature ());
}
[Test]
public void CheckSignatureEmpty ()
{
SignedXml sx = new SignedXml ();
- Assert (!sx.CheckSignature ());
+ Assert.IsTrue (!sx.CheckSignature ());
}
[Test]
byte [] key = Convert.FromBase64String (
"1W5EigVnbnRjGLbg99ElieOmuUgYO+KcwMJtE35SAGI=");
Transform t = new XmlDsigC14NTransform ();
- AssertEquals ("#1", expected, SignWithHMACSHA1 (input, key, t));
+ Assert.AreEqual (expected, SignWithHMACSHA1 (input, key, t), "#1");
// The second result should be still identical.
- AssertEquals ("#2", expected, SignWithHMACSHA1 (input, key, t));
+ Assert.AreEqual (expected, SignWithHMACSHA1 (input, key, t), "#2");
}
[Test]
byte [] key = Convert.FromBase64String (
"1W5EigVnbnRjGLbg99ElieOmuUgYO+KcwMJtE35SAGI=");
- AssertEquals (expected, SignWithHMACSHA1 (input, key));
+ Assert.AreEqual (SignWithHMACSHA1 (input, key), expected);
}
string SignWithHMACSHA1 (string input, byte [] key)
public void GetIdElement_Null ()
{
SignedXml sign = new SignedXml ();
- AssertNull (sign.GetIdElement (null, "value"));
- AssertNull (sign.GetIdElement (new XmlDocument (), null));
+ Assert.IsNull (sign.GetIdElement (null, "value"));
+ Assert.IsNull (sign.GetIdElement (new XmlDocument (), null));
}
#if NET_2_0
transform.LoadInput (doc);
Stream s = (Stream) transform.GetOutput ();
string output = Stream2String (s);
- AssertEquals ("#1", "<person>
\n <birthplace>Brussels</birthplace>
\n</person>", output);
+ Assert.AreEqual ("<person>
\n <birthplace>Brussels</birthplace>
\n</person>", output, "#1");
s.Position = 0;
HashAlgorithm hash = HashAlgorithm.Create ("System.Security.Cryptography.SHA1CryptoServiceProvider");
byte[] digest = hash.ComputeHash (s);
- AssertEquals ("#2", "IKbfdK2/DMfXyezCf5QggVCXfk8=", Convert.ToBase64String (digest));
+ Assert.AreEqual ("IKbfdK2/DMfXyezCf5QggVCXfk8=", Convert.ToBase64String (digest), "#2");
X509Certificate2 cert = new X509Certificate2 (_pkcs12, "mono");
SignedXml signedXml = new SignedXml (doc);
signedXml.ComputeSignature ();
digest = reference.DigestValue;
- AssertEquals ("#3", "e3dsi1xK8FAx1vsug7J203JbEAU=", Convert.ToBase64String (digest));
+ Assert.AreEqual ("e3dsi1xK8FAx1vsug7J203JbEAU=", Convert.ToBase64String (digest), "#3");
- AssertEquals ("#4", "<SignedInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\">"
+ Assert.AreEqual ("<SignedInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\">"
+ "<CanonicalizationMethod Algorithm=\"http://www.w3.org/2001/10/xml-exc-c14n#\" />"
+ "<SignatureMethod Algorithm=\"http://www.w3.org/2000/09/xmldsig#rsa-sha1\" />"
+ "<Reference URI=\"\">"
+ "<DigestMethod Algorithm=\"http://www.w3.org/2000/09/xmldsig#sha1\" />"
+ "<DigestValue>e3dsi1xK8FAx1vsug7J203JbEAU=</DigestValue>"
+ "</Reference>"
- + "</SignedInfo>", signedXml.SignedInfo.GetXml ().OuterXml);
+ + "</SignedInfo>", signedXml.SignedInfo.GetXml ().OuterXml, "#4");
}
[Test]
transform.LoadInput (doc);
Stream s = (Stream) transform.GetOutput ();
string output = Stream2String (s);
- AssertEquals ("#1", "<person>\n <birthplace>Brussels</birthplace>\n</person>", output);
+ Assert.AreEqual ("<person>\n <birthplace>Brussels</birthplace>\n</person>", output, "#1");
s.Position = 0;
HashAlgorithm hash = HashAlgorithm.Create ("System.Security.Cryptography.SHA1CryptoServiceProvider");
byte[] digest = hash.ComputeHash (s);
- AssertEquals ("#2", "e3dsi1xK8FAx1vsug7J203JbEAU=", Convert.ToBase64String (digest));
+ Assert.AreEqual ("e3dsi1xK8FAx1vsug7J203JbEAU=", Convert.ToBase64String (digest), "#2");
X509Certificate2 cert = new X509Certificate2 (_pkcs12, "mono");
SignedXml signedXml = new SignedXml (doc);
signedXml.ComputeSignature ();
digest = reference.DigestValue;
- AssertEquals ("#3", "e3dsi1xK8FAx1vsug7J203JbEAU=", Convert.ToBase64String (digest));
+ Assert.AreEqual ("e3dsi1xK8FAx1vsug7J203JbEAU=", Convert.ToBase64String (digest), "#3");
- AssertEquals ("#4", "<SignedInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\">"
+ Assert.AreEqual ("<SignedInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\">"
+ "<CanonicalizationMethod Algorithm=\"http://www.w3.org/2001/10/xml-exc-c14n#\" />"
+ "<SignatureMethod Algorithm=\"http://www.w3.org/2000/09/xmldsig#rsa-sha1\" />"
+ "<Reference URI=\"\">"
+ "<DigestMethod Algorithm=\"http://www.w3.org/2000/09/xmldsig#sha1\" />"
+ "<DigestValue>e3dsi1xK8FAx1vsug7J203JbEAU=</DigestValue>"
+ "</Reference>"
- + "</SignedInfo>", signedXml.SignedInfo.GetXml ().OuterXml);
+ + "</SignedInfo>", signedXml.SignedInfo.GetXml ().OuterXml, "#4");
}
[Test]
SignedXml signedXml = new SignedXml (doc);
XmlNodeList nodeList = doc.GetElementsByTagName ("Signature");
signedXml.LoadXml ((XmlElement) nodeList [0]);
- Assert ("#2", !signedXml.CheckSignature ());
+ Assert.IsTrue (!signedXml.CheckSignature (), "#2");
}
[Test]
X509Certificate2 cert = new X509Certificate2 (_pkcs12, "mono");
XmlDocument doc = CreateSignedXml (cert, SignedXml.XmlDsigExcC14NTransformUrl, "\r\n");
- AssertEquals ("#1", string.Format (CultureInfo.InvariantCulture,
- "<person>{0}" +
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture, "<person>{0}" +
" <birthplace>Brussels</birthplace>{0}" +
"<Signature xmlns=\"http://www.w3.org/2000/09/xmldsig#\">" +
"<SignedInfo>" +
"</X509Data>" +
"</KeyInfo>" +
"</Signature>" +
- "</person>", "\r\n"), doc.OuterXml);
+ "</person>", "\r\n"), doc.OuterXml, "#1");
}
[Test]
X509Certificate2 cert = new X509Certificate2 (_pkcs12, "mono");
XmlDocument doc = CreateSignedXml (cert, SignedXml.XmlDsigExcC14NTransformUrl, "\n");
- AssertEquals ("#1", string.Format (CultureInfo.InvariantCulture,
- "<person>{0}" +
+ Assert.AreEqual (string.Format (CultureInfo.InvariantCulture, "<person>{0}" +
" <birthplace>Brussels</birthplace>{0}" +
"<Signature xmlns=\"http://www.w3.org/2000/09/xmldsig#\">" +
"<SignedInfo>" +
"</X509Data>" +
"</KeyInfo>" +
"</Signature>" +
- "</person>", "\n"), doc.OuterXml);
+ "</person>", "\n"), doc.OuterXml, "#1");
}
[Test] // part of bug #79454
X509Certificate2 cert = new X509Certificate2 (_pkcs12, "mono");
doc = CreateSignedXml (cert, SignedXml.XmlDsigExcC14NTransformUrl, "\n");
- Assert ("#1", VerifySignedXml (doc));
+ Assert.IsTrue (VerifySignedXml (doc), "#1");
doc = CreateSignedXml (cert, SignedXml.XmlDsigExcC14NWithCommentsTransformUrl, "\n");
- Assert ("#2", VerifySignedXml (doc));
+ Assert.IsTrue (VerifySignedXml (doc), "#2");
doc = CreateSignedXml (cert, SignedXml.XmlDsigCanonicalizationUrl, "\n");
- Assert ("#3", VerifySignedXml (doc));
+ Assert.IsTrue (VerifySignedXml (doc), "#3");
doc = CreateSignedXml (cert, SignedXml.XmlDsigCanonicalizationWithCommentsUrl, "\n");
- Assert ("#4", VerifySignedXml (doc));
+ Assert.IsTrue (VerifySignedXml (doc), "#4");
}
// creates a signed XML document with two certificates in the X509Data
// doc.Save (System.Console.Out);
sig.LoadXml (doc.DocumentElement ["Signature"]);
- AssertEquals ("CheckSignature", ok, sig.CheckSignature (mac));
+ Assert.AreEqual (ok, sig.CheckSignature (mac), "CheckSignature");
return sig;
}
public void SignHMAC_SHA256 ()
{
SignedXml sign = SignHMAC (EncryptedXml.XmlEncSHA256Url, new HMACSHA256 (hmackey), true);
- AssertEquals ("SignatureMethod", more256, sign.SignatureMethod);
+ Assert.AreEqual (more256, sign.SignatureMethod, "SignatureMethod");
}
[Test]
public void SignHMAC_SHA256_Bad ()
{
SignedXml sign = SignHMAC (more256, new HMACSHA256 (hmackey), false);
- AssertEquals ("SignatureMethod", more256, sign.SignatureMethod);
+ Assert.AreEqual (more256, sign.SignatureMethod, "SignatureMethod");
}
[Test]
sign.LoadXml (doc.DocumentElement ["Signature"]);
// verify MS-generated signature
- Assert (sign.CheckSignature (new HMACSHA256 (hmackey)));
+ Assert.IsTrue (sign.CheckSignature (new HMACSHA256 (hmackey)));
}
[Test]
public void SignHMAC_SHA512 ()
{
SignedXml sign = SignHMAC (EncryptedXml.XmlEncSHA512Url, new HMACSHA512 (hmackey), true);
- AssertEquals ("SignatureMethod", more512, sign.SignatureMethod);
+ Assert.AreEqual (more512, sign.SignatureMethod, "SignatureMethod");
}
[Test]
public void SignHMAC_SHA512_Bad ()
{
SignedXml sign = SignHMAC (more512, new HMACSHA512 (hmackey), false);
- AssertEquals ("SignatureMethod", more512, sign.SignatureMethod);
+ Assert.AreEqual (more512, sign.SignatureMethod, "SignatureMethod");
}
[Test]
sign.LoadXml (doc.DocumentElement ["Signature"]);
// verify MS-generated signature
- Assert (sign.CheckSignature (new HMACSHA512 (hmackey)));
+ Assert.IsTrue (sign.CheckSignature (new HMACSHA512 (hmackey)));
}
[Test]
// works as long as the string can be used by CryptoConfig to create
// an instance of the required hash algorithm
SignedXml sign = SignHMAC ("SHA384", new HMACSHA384 (hmackey), true);
- AssertEquals ("SignatureMethod", more384, sign.SignatureMethod);
+ Assert.AreEqual (more384, sign.SignatureMethod, "SignatureMethod");
}
[Test]
{
// we can't verity the signature if the URI is used
SignedXml sign = SignHMAC (more384, new HMACSHA384 (hmackey), false);
- AssertEquals ("SignatureMethod", more384, sign.SignatureMethod);
+ Assert.AreEqual (more384, sign.SignatureMethod, "SignatureMethod");
}
[Test]
sign.LoadXml (doc.DocumentElement ["Signature"]);
// verify MS-generated signature
- Assert (sign.CheckSignature (new HMACSHA384 (hmackey)));
+ Assert.IsTrue (sign.CheckSignature (new HMACSHA384 (hmackey)));
}
[Test]
// works as long as the string can be used by CryptoConfig to create
// an instance of the required hash algorithm
SignedXml sign = SignHMAC ("RIPEMD160", new HMACRIPEMD160 (hmackey), true);
- AssertEquals ("SignatureMethod", moreripe, sign.SignatureMethod);
+ Assert.AreEqual (moreripe, sign.SignatureMethod, "SignatureMethod");
}
[Test]
{
// we can't verity the signature if the URI is used
SignedXml sign = SignHMAC (moreripe, new HMACRIPEMD160 (hmackey), false);
- AssertEquals ("SignatureMethod", moreripe, sign.SignatureMethod);
+ Assert.AreEqual (moreripe, sign.SignatureMethod, "SignatureMethod");
}
[Test]
sign.LoadXml (doc.DocumentElement ["Signature"]);
// verify MS-generated signature
- Assert (sign.CheckSignature (new HMACRIPEMD160 (hmackey)));
+ Assert.IsTrue (sign.CheckSignature (new HMACRIPEMD160 (hmackey)));
}
#endif
}
namespace MonoTests.System.Security.Cryptography.Xml {
[TestFixture]
- public class TransformChainTest : Assertion {
+ public class TransformChainTest {
[Test]
public void EmptyChain ()
{
TransformChain chain = new TransformChain ();
- AssertEquals ("empty count", 0, chain.Count);
- AssertNotNull ("IEnumerator", chain.GetEnumerator ());
- AssertEquals ("ToString()", "System.Security.Cryptography.Xml.TransformChain", chain.ToString ());
+ Assert.AreEqual (0, chain.Count, "empty count");
+ Assert.IsNotNull (chain.GetEnumerator (), "IEnumerator");
+ Assert.AreEqual ("System.Security.Cryptography.Xml.TransformChain", chain.ToString (), "ToString()");
}
[Test]
XmlDsigBase64Transform base64 = new XmlDsigBase64Transform ();
chain.Add (base64);
- AssertEquals ("XmlDsigBase64Transform", base64, chain[0]);
- AssertEquals ("count 1", 1, chain.Count);
+ Assert.AreEqual (base64, chain[0], "XmlDsigBase64Transform");
+ Assert.AreEqual (1, chain.Count, "count 1");
XmlDsigC14NTransform c14n = new XmlDsigC14NTransform ();
chain.Add (c14n);
- AssertEquals ("XmlDsigC14NTransform", c14n, chain[1]);
- AssertEquals ("count 2", 2, chain.Count);
+ Assert.AreEqual (c14n, chain[1], "XmlDsigC14NTransform");
+ Assert.AreEqual (2, chain.Count, "count 2");
XmlDsigC14NWithCommentsTransform c14nc = new XmlDsigC14NWithCommentsTransform ();
chain.Add (c14nc);
- AssertEquals ("XmlDsigC14NWithCommentsTransform", c14nc, chain[2]);
- AssertEquals ("count 3", 3, chain.Count);
+ Assert.AreEqual (c14nc, chain[2], "XmlDsigC14NWithCommentsTransform");
+ Assert.AreEqual (3, chain.Count, "count 3");
XmlDsigEnvelopedSignatureTransform esign = new XmlDsigEnvelopedSignatureTransform ();
chain.Add (esign);
- AssertEquals ("XmlDsigEnvelopedSignatureTransform", esign, chain[3]);
- AssertEquals ("count 4", 4, chain.Count);
+ Assert.AreEqual (esign, chain[3], "XmlDsigEnvelopedSignatureTransform");
+ Assert.AreEqual (4, chain.Count, "count 4");
XmlDsigXPathTransform xpath = new XmlDsigXPathTransform ();
chain.Add (xpath);
- AssertEquals ("XmlDsigXPathTransform", xpath, chain[4]);
- AssertEquals ("count 5", 5, chain.Count);
+ Assert.AreEqual (xpath, chain[4], "XmlDsigXPathTransform");
+ Assert.AreEqual (5, chain.Count, "count 5");
XmlDsigXsltTransform xslt = new XmlDsigXsltTransform ();
chain.Add (xslt);
- AssertEquals ("XmlDsigXsltTransform", xslt, chain[5]);
- AssertEquals ("count 6", 6, chain.Count);
+ Assert.AreEqual (xslt, chain[5], "XmlDsigXsltTransform");
+ Assert.AreEqual (6, chain.Count, "count 6");
}
}
}
}
[TestFixture]
- public class XmlDsigBase64TransformTest : Assertion {
+ public class XmlDsigBase64TransformTest {
protected UnprotectedXmlDsigBase64Transform transform;
[Test]
public void Properties ()
{
- AssertEquals ("Algorithm", "http://www.w3.org/2000/09/xmldsig#base64", transform.Algorithm);
+ Assert.AreEqual ("http://www.w3.org/2000/09/xmldsig#base64", transform.Algorithm, "Algorithm");
Type[] input = transform.InputTypes;
- Assert ("Input #", (input.Length == 3));
+ Assert.IsTrue ((input.Length == 3), "Input #");
// check presence of every supported input types
bool istream = false;
bool ixmldoc = false;
if (t.ToString () == "System.Xml.XmlNodeList")
ixmlnl = true;
}
- Assert ("Input Stream", istream);
- Assert ("Input XmlDocument", ixmldoc);
- Assert ("Input XmlNodeList", ixmlnl);
+ Assert.IsTrue (istream, "Input Stream");
+ Assert.IsTrue (ixmldoc, "Input XmlDocument");
+ Assert.IsTrue (ixmlnl, "Input XmlNodeList");
Type[] output = transform.OutputTypes;
- Assert ("Output #", (output.Length == 1));
+ Assert.IsTrue ((output.Length == 1), "Output #");
// check presence of every supported output types
bool ostream = false;
foreach (Type t in input) {
if (t.ToString () == "System.IO.Stream")
ostream = true;
}
- Assert ("Output Stream", ostream);
+ Assert.IsTrue (ostream, "Output Stream");
}
[Test]
input [2] = null;
// property does not return a clone
foreach (Type t in transform.InputTypes) {
- AssertNull (t);
+ Assert.IsNull (t);
}
// it's not a static array
XmlDsigBase64Transform t2 = new XmlDsigBase64Transform ();
foreach (Type t in t2.InputTypes) {
- AssertNotNull (t);
+ Assert.IsNotNull (t);
}
}
public void GetInnerXml ()
{
XmlNodeList xnl = transform.UnprotectedGetInnerXml ();
- AssertNull ("Default InnerXml", xnl);
+ Assert.IsNull (xnl, "Default InnerXml");
}
private string Stream2String (Stream s)
transform.LoadInput (doc);
Stream s = (Stream) transform.GetOutput ();
string output = Stream2String (s);
- AssertEquals("XmlDocument", base64, output);
+ Assert.AreEqual (base64, output, "XmlDocument");
}
[Test]
{
XmlDocument doc = GetDoc ();
XmlNodeList xpath = doc.SelectNodes ("//.");
- AssertEquals("XPathNodeList.Count", 3, xpath.Count);
+ Assert.AreEqual (3, xpath.Count, "XPathNodeList.Count");
transform.LoadInput (xpath);
Stream s = (Stream) transform.GetOutput ();
string output = Stream2String (s);
- AssertEquals ("XPathNodeList", base64, output);
+ Assert.AreEqual (base64, output, "XPathNodeList");
}
[Test]
Stream s = (Stream) transform.GetOutput ();
string output = Stream2String (s);
// Note that ChildNodes does not contain the text node.
- AssertEquals ("XmlChildNodes", String.Empty, output);
+ Assert.AreEqual (String.Empty, output, "XmlChildNodes");
}
[Test]
transform.LoadInput (ms);
Stream s = (Stream) transform.GetOutput ();
string output = Stream2String (s);
- AssertEquals ("MemoryStream", base64, output);
+ Assert.AreEqual (base64, output, "MemoryStream");
}
[Test]
}
[TestFixture]
- public class XmlDsigC14NTransformTest : Assertion {
+ public class XmlDsigC14NTransformTest {
protected UnprotectedXmlDsigC14NTransform transform;
[Test] // ctor ()
public void Constructor1 ()
{
- AssertEquals ("Algorithm", "http://www.w3.org/TR/2001/REC-xml-c14n-20010315", transform.Algorithm);
+ Assert.AreEqual ("http://www.w3.org/TR/2001/REC-xml-c14n-20010315", transform.Algorithm, "Algorithm");
CheckProperties (transform);
}
public void Constructor2 ()
{
transform = new UnprotectedXmlDsigC14NTransform (true);
- AssertEquals ("Algorithm", "http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments", transform.Algorithm);
+ Assert.AreEqual ("http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments", transform.Algorithm, "Algorithm");
CheckProperties (transform);
transform = new UnprotectedXmlDsigC14NTransform (false);
- AssertEquals ("Algorithm", "http://www.w3.org/TR/2001/REC-xml-c14n-20010315", transform.Algorithm);
+ Assert.AreEqual ("http://www.w3.org/TR/2001/REC-xml-c14n-20010315", transform.Algorithm, "Algorithm");
CheckProperties (transform);
}
void CheckProperties (XmlDsigC14NTransform transform)
{
Type[] input = transform.InputTypes;
- Assert ("Input #", (input.Length == 3));
+ Assert.IsTrue ((input.Length == 3), "Input #");
// check presence of every supported input types
bool istream = false;
bool ixmldoc = false;
if (t.ToString () == "System.Xml.XmlNodeList")
ixmlnl = true;
}
- Assert ("Input Stream", istream);
- Assert ("Input XmlDocument", ixmldoc);
- Assert ("Input XmlNodeList", ixmlnl);
+ Assert.IsTrue (istream, "Input Stream");
+ Assert.IsTrue (ixmldoc, "Input XmlDocument");
+ Assert.IsTrue (ixmlnl, "Input XmlNodeList");
Type[] output = transform.OutputTypes;
- Assert ("Output #", (output.Length == 1));
+ Assert.IsTrue ((output.Length == 1), "Output #");
// check presence of every supported output types
bool ostream = false;
foreach (Type t in output) {
if (t.ToString () == "System.IO.Stream")
ostream = true;
}
- Assert ("Output Stream", ostream);
+ Assert.IsTrue (ostream, "Output Stream");
}
[Test]
public void GetInnerXml ()
{
XmlNodeList xnl = transform.UnprotectedGetInnerXml ();
- AssertNull ("Default InnerXml", xnl);
+ Assert.IsNull (xnl, "Default InnerXml");
}
private string Stream2String (Stream s)
Stream s = (Stream) transform.GetOutput ();
string output = Stream2String (s);
#if NET_1_1
- AssertEquals("XmlDocument", c14xml3, output);
+ Assert.AreEqual (c14xml3, output, "XmlDocument");
#else
// .NET 1.0 keeps the \r\n (0x0D, 0x0A) - bug
- AssertEquals("XmlDocument", c14xml1, output);
+ Assert.AreEqual (c14xml1, output, "XmlDocument");
#endif
}
transform.LoadInput (doc.ChildNodes);
Stream s = (Stream) transform.GetOutput ();
string output = Stream2String (s);
- AssertEquals ("XmlChildNodes", "<Test></Test>", output);
+ Assert.AreEqual ("<Test></Test>", output, "XmlChildNodes");
}
[Test]
Stream s = (Stream) transform.GetOutput ();
string output = Stream2String (s);
string expected = @"<Test><Toto></Toto></Test>";
- AssertEquals ("XmlChildNodes", expected, output);
+ Assert.AreEqual (expected, output, "XmlChildNodes");
}
[Test]
transform.LoadInput (ms);
Stream s = (Stream) transform.GetOutput ();
string output = Stream2String (s);
- AssertEquals ("MemoryStream", c14xml2, output);
+ Assert.AreEqual (c14xml2, output, "MemoryStream");
}
[Test]
sw.Close ();
}
string res = ExecuteXmlDSigC14NTransform (C14NSpecExample1Input);
- AssertEquals ("Example 1 from c14n spec - PIs, Comments, and Outside of Document Element (without comments)",
- C14NSpecExample1Output, res);
+ Assert.AreEqual (C14NSpecExample1Output, res, "Example 1 from c14n spec - PIs, Comments, and Outside of Document Element (without comments)");
}
[Test]
public void C14NSpecExample2 ()
{
string res = ExecuteXmlDSigC14NTransform (C14NSpecExample2Input);
- AssertEquals ("Example 2 from c14n spec - Whitespace in Document Content (without comments)",
- C14NSpecExample2Output, res);
+ Assert.AreEqual (C14NSpecExample2Output, res, "Example 2 from c14n spec - Whitespace in Document Content (without comments)");
}
[Test]
public void C14NSpecExample3 ()
{
string res = ExecuteXmlDSigC14NTransform (C14NSpecExample3Input);
- AssertEquals ("Example 3 from c14n spec - Start and End Tags (without comments)",
- C14NSpecExample3Output, res);
+ Assert.AreEqual (C14NSpecExample3Output, res, "Example 3 from c14n spec - Start and End Tags (without comments)");
}
[Test]
public void C14NSpecExample4 ()
{
string res = ExecuteXmlDSigC14NTransform (C14NSpecExample4Input);
- AssertEquals ("Example 4 from c14n spec - Character Modifications and Character References (without comments)",
- C14NSpecExample4Output, res);
+ Assert.AreEqual (C14NSpecExample4Output, res, "Example 4 from c14n spec - Character Modifications and Character References (without comments)");
}
[Test]
sw.Close ();
}
string res = ExecuteXmlDSigC14NTransform (C14NSpecExample5Input);
- AssertEquals ("Example 5 from c14n spec - Entity References (without comments)",
- C14NSpecExample5Output, res);
+ Assert.AreEqual (C14NSpecExample5Output, res, "Example 5 from c14n spec - Entity References (without comments)");
}
[Test]
public void C14NSpecExample6 ()
{
string res = ExecuteXmlDSigC14NTransform (C14NSpecExample6Input);
- AssertEquals ("Example 6 from c14n spec - UTF-8 Encoding (without comments)",
- C14NSpecExample6Output, res);
+ Assert.AreEqual (C14NSpecExample6Output, res, "Example 6 from c14n spec - UTF-8 Encoding (without comments)");
}
private string ExecuteXmlDSigC14NTransform (string InputXml)
XmlDsigC14NTransform t = new XmlDsigC14NTransform ();
t.LoadInput (doc);
Stream s = t.GetOutput () as Stream;
- AssertEquals (expected, new StreamReader (s, Encoding.UTF8).ReadToEnd ());
+ Assert.AreEqual (new StreamReader (s, Encoding.UTF8).ReadToEnd (), expected);
}
#if NET_2_0
XmlDocument doc = new XmlDocument ();
doc.AppendChild (doc.CreateElement ("foo", "urn:foo"));
doc.DocumentElement.AppendChild (doc.CreateElement ("bar", "urn:bar"));
- AssertEquals ("#1", String.Empty, doc.DocumentElement.GetAttribute ("xmlns"));
+ Assert.AreEqual (String.Empty, doc.DocumentElement.GetAttribute ("xmlns"), "#1");
XmlDsigC14NTransform t = new XmlDsigC14NTransform ();
t.LoadInput (doc);
Stream s = t.GetOutput () as Stream;
- AssertEquals ("<foo xmlns=\"urn:foo\"><bar xmlns=\"urn:bar\"></bar></foo>", new StreamReader (s, Encoding.UTF8).ReadToEnd ());
- AssertEquals ("#2", "urn:foo", doc.DocumentElement.GetAttribute ("xmlns"));
+ Assert.AreEqual (new StreamReader (s, Encoding.UTF8).ReadToEnd (), "<foo xmlns=\"urn:foo\"><bar xmlns=\"urn:bar\"></bar></foo>");
+ Assert.AreEqual ("urn:foo", doc.DocumentElement.GetAttribute ("xmlns"), "#2");
}
[Test]
XmlDocument doc = new XmlDocument ();
doc.AppendChild (doc.CreateElement ("foo", "urn:foo"));
doc.DocumentElement.AppendChild (doc.CreateElement ("bar", "urn:bar"));
- AssertEquals ("#1", String.Empty, doc.DocumentElement.GetAttribute ("xmlns:f"));
+ Assert.AreEqual (String.Empty, doc.DocumentElement.GetAttribute ("xmlns:f"), "#1");
XmlDsigExcC14NTransform t = new XmlDsigExcC14NTransform ();
t.LoadInput (doc);
t.PropagatedNamespaces.Add ("f", "urn:foo");
t.PropagatedNamespaces.Add ("b", "urn:bar");
Stream s = t.GetOutput () as Stream;
- AssertEquals ("<f:foo xmlns:f=\"urn:foo\"><b:bar xmlns:b=\"urn:bar\"></b:bar></f:foo>", new StreamReader (s, Encoding.UTF8).ReadToEnd ());
- AssertEquals ("#2", "urn:foo", doc.DocumentElement.GetAttribute ("xmlns:f"));
+ Assert.AreEqual (new StreamReader (s, Encoding.UTF8).ReadToEnd (), "<f:foo xmlns:f=\"urn:foo\"><b:bar xmlns:b=\"urn:bar\"></b:bar></f:foo>");
+ Assert.AreEqual ("urn:foo", doc.DocumentElement.GetAttribute ("xmlns:f"), "#2");
}
[Test]
}
[TestFixture]
- public class XmlDsigC14NWithCommentsTransformTest : Assertion {
+ public class XmlDsigC14NWithCommentsTransformTest {
protected UnprotectedXmlDsigC14NWithCommentsTransform transform;
[Test]
public void Properties ()
{
- AssertEquals ("Algorithm", "http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments", transform.Algorithm);
+ Assert.AreEqual ("http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments", transform.Algorithm, "Algorithm");
Type[] input = transform.InputTypes;
- Assert ("Input #", (input.Length == 3));
+ Assert.IsTrue ((input.Length == 3), "Input #");
// check presence of every supported input types
bool istream = false;
bool ixmldoc = false;
if (t.ToString () == "System.Xml.XmlNodeList")
ixmlnl = true;
}
- Assert ("Input Stream", istream);
- Assert ("Input XmlDocument", ixmldoc);
- Assert ("Input XmlNodeList", ixmlnl);
+ Assert.IsTrue (istream, "Input Stream");
+ Assert.IsTrue (ixmldoc, "Input XmlDocument");
+ Assert.IsTrue (ixmlnl, "Input XmlNodeList");
Type[] output = transform.OutputTypes;
- Assert ("Output #", (output.Length == 1));
+ Assert.IsTrue ((output.Length == 1), "Output #");
// check presence of every supported output types
bool ostream = false;
foreach (Type t in output) {
if (t.ToString () == "System.IO.Stream")
ostream = true;
}
- Assert ("Output Stream", ostream);
+ Assert.IsTrue (ostream, "Output Stream");
}
[Test]
public void GetInnerXml ()
{
XmlNodeList xnl = transform.UnprotectedGetInnerXml ();
- AssertEquals ("Default InnerXml", null, xnl);
+ Assert.AreEqual (null, xnl, "Default InnerXml");
}
#if NET_2_0
sw.Close ();
}
string res = ExecuteXmlDSigC14NTransform (C14NSpecExample1Input, true);
- AssertEquals ("Example 1 from c14n spec - PIs, Comments, and Outside of Document Element (with comments)",
- C14NSpecExample1Output, res);
+ Assert.AreEqual (C14NSpecExample1Output, res, "Example 1 from c14n spec - PIs, Comments, and Outside of Document Element (with comments)");
}
[Test]
NUnit.Framework.Assert.Ignore ("SecurityManager isn't enabled.");
#endif
string res = ExecuteXmlDSigC14NTransform (C14NSpecExample1Input, false);
- AssertEquals ("Example 1 from c14n spec - PIs, Comments, and Outside of Document Element (with comments)",
- C14NSpecExample1Output, res);
+ Assert.AreEqual (C14NSpecExample1Output, res, "Example 1 from c14n spec - PIs, Comments, and Outside of Document Element (with comments)");
}
[Test]
public void C14NSpecExample2 ()
{
string res = ExecuteXmlDSigC14NTransform (C14NSpecExample2Input, false);
- AssertEquals ("Example 2 from c14n spec - Whitespace in Document Content (with comments)",
- C14NSpecExample2Output, res);
+ Assert.AreEqual (C14NSpecExample2Output, res, "Example 2 from c14n spec - Whitespace in Document Content (with comments)");
}
[Test]
public void C14NSpecExample3 ()
{
string res = ExecuteXmlDSigC14NTransform (C14NSpecExample3Input, false);
- AssertEquals ("Example 3 from c14n spec - Start and End Tags (with comments)",
- C14NSpecExample3Output, res);
+ Assert.AreEqual (C14NSpecExample3Output, res, "Example 3 from c14n spec - Start and End Tags (with comments)");
}
[Test]
public void C14NSpecExample4 ()
{
string res = ExecuteXmlDSigC14NTransform (C14NSpecExample4Input, false);
- AssertEquals ("Example 4 from c14n spec - Character Modifications and Character References (with comments)",
- C14NSpecExample4Output, res);
+ Assert.AreEqual (C14NSpecExample4Output, res, "Example 4 from c14n spec - Character Modifications and Character References (with comments)");
}
[Test]
}
}
string res = ExecuteXmlDSigC14NTransform (C14NSpecExample5Input, false);
- AssertEquals ("Example 5 from c14n spec - Entity References (with comments)",
- C14NSpecExample5Output, res);
+ Assert.AreEqual (C14NSpecExample5Output, res, "Example 5 from c14n spec - Entity References (with comments)");
}
[Test]
public void C14NSpecExample6 ()
{
string res = ExecuteXmlDSigC14NTransform (C14NSpecExample6Input, false);
- AssertEquals ("Example 6 from c14n spec - UTF-8 Encoding (with comments)",
- C14NSpecExample6Output, res);
+ Assert.AreEqual (C14NSpecExample6Output, res, "Example 6 from c14n spec - UTF-8 Encoding (with comments)");
}
private string ExecuteXmlDSigC14NTransform (string InputXml, bool resolver)
}
[TestFixture]
- public class XmlDsigExcC14NTransformTest : Assertion {
+ public class XmlDsigExcC14NTransformTest {
protected UnprotectedXmlDsigExcC14NTransform transform;
[Test] // ctor ()
public void Constructor1 ()
{
- AssertEquals ("Algorithm", "http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm);
- AssertNull ("InclusiveNamespacesPrefixList", transform.InclusiveNamespacesPrefixList);
+ Assert.AreEqual ("http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm, "Algorithm");
+ Assert.IsNull (transform.InclusiveNamespacesPrefixList, "InclusiveNamespacesPrefixList");
CheckProperties (transform);
}
public void Constructor2 ()
{
transform = new UnprotectedXmlDsigExcC14NTransform (true);
- AssertEquals ("Algorithm", "http://www.w3.org/2001/10/xml-exc-c14n#WithComments", transform.Algorithm);
- AssertNull ("InclusiveNamespacesPrefixList", transform.InclusiveNamespacesPrefixList);
+ Assert.AreEqual ("http://www.w3.org/2001/10/xml-exc-c14n#WithComments", transform.Algorithm, "Algorithm");
+ Assert.IsNull (transform.InclusiveNamespacesPrefixList, "InclusiveNamespacesPrefixList");
CheckProperties (transform);
transform = new UnprotectedXmlDsigExcC14NTransform (false);
- AssertEquals ("Algorithm", "http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm);
- AssertNull ("InclusiveNamespacesPrefixList", transform.InclusiveNamespacesPrefixList);
+ Assert.AreEqual ("http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm, "Algorithm");
+ Assert.IsNull (transform.InclusiveNamespacesPrefixList, "InclusiveNamespacesPrefixList");
CheckProperties (transform);
}
public void Constructor3 ()
{
transform = new UnprotectedXmlDsigExcC14NTransform (null);
- AssertEquals ("Algorithm", "http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm);
- AssertNull ("InclusiveNamespacesPrefixList", transform.InclusiveNamespacesPrefixList);
+ Assert.AreEqual ("http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm, "Algorithm");
+ Assert.IsNull (transform.InclusiveNamespacesPrefixList, "InclusiveNamespacesPrefixList");
CheckProperties (transform);
transform = new UnprotectedXmlDsigExcC14NTransform (string.Empty);
- AssertEquals ("Algorithm", "http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm);
- AssertEquals ("InclusiveNamespacesPrefixList", string.Empty, transform.InclusiveNamespacesPrefixList);
+ Assert.AreEqual ("http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm, "Algorithm");
+ Assert.AreEqual (string.Empty, transform.InclusiveNamespacesPrefixList, "InclusiveNamespacesPrefixList");
CheckProperties (transform);
transform = new UnprotectedXmlDsigExcC14NTransform ("#default xsd");
- AssertEquals ("Algorithm", "http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm);
- AssertEquals ("InclusiveNamespacesPrefixList", "#default xsd", transform.InclusiveNamespacesPrefixList);
+ Assert.AreEqual ("http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm, "Algorithm");
+ Assert.AreEqual ("#default xsd", transform.InclusiveNamespacesPrefixList, "InclusiveNamespacesPrefixList");
CheckProperties (transform);
}
public void Constructor4 ()
{
transform = new UnprotectedXmlDsigExcC14NTransform (true, null);
- AssertEquals ("Algorithm", "http://www.w3.org/2001/10/xml-exc-c14n#WithComments", transform.Algorithm);
- AssertNull ("InclusiveNamespacesPrefixList", transform.InclusiveNamespacesPrefixList);
+ Assert.AreEqual ("http://www.w3.org/2001/10/xml-exc-c14n#WithComments", transform.Algorithm, "Algorithm");
+ Assert.IsNull (transform.InclusiveNamespacesPrefixList, "InclusiveNamespacesPrefixList");
CheckProperties (transform);
transform = new UnprotectedXmlDsigExcC14NTransform (true, string.Empty);
- AssertEquals ("Algorithm", "http://www.w3.org/2001/10/xml-exc-c14n#WithComments", transform.Algorithm);
- AssertEquals ("InclusiveNamespacesPrefixList", string.Empty, transform.InclusiveNamespacesPrefixList);
+ Assert.AreEqual ("http://www.w3.org/2001/10/xml-exc-c14n#WithComments", transform.Algorithm, "Algorithm");
+ Assert.AreEqual (string.Empty, transform.InclusiveNamespacesPrefixList, "InclusiveNamespacesPrefixList");
CheckProperties (transform);
transform = new UnprotectedXmlDsigExcC14NTransform (true, "#default xsd");
- AssertEquals ("Algorithm", "http://www.w3.org/2001/10/xml-exc-c14n#WithComments", transform.Algorithm);
- AssertEquals ("InclusiveNamespacesPrefixList", "#default xsd", transform.InclusiveNamespacesPrefixList);
+ Assert.AreEqual ("http://www.w3.org/2001/10/xml-exc-c14n#WithComments", transform.Algorithm, "Algorithm");
+ Assert.AreEqual ("#default xsd", transform.InclusiveNamespacesPrefixList, "InclusiveNamespacesPrefixList");
CheckProperties (transform);
transform = new UnprotectedXmlDsigExcC14NTransform (false, null);
- AssertEquals ("Algorithm", "http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm);
- AssertNull ("InclusiveNamespacesPrefixList", transform.InclusiveNamespacesPrefixList);
+ Assert.AreEqual ("http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm, "Algorithm");
+ Assert.IsNull (transform.InclusiveNamespacesPrefixList, "InclusiveNamespacesPrefixList");
CheckProperties (transform);
transform = new UnprotectedXmlDsigExcC14NTransform (false, string.Empty);
- AssertEquals ("Algorithm", "http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm);
- AssertEquals ("InclusiveNamespacesPrefixList", string.Empty, transform.InclusiveNamespacesPrefixList);
+ Assert.AreEqual ("http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm, "Algorithm");
+ Assert.AreEqual (string.Empty, transform.InclusiveNamespacesPrefixList, "InclusiveNamespacesPrefixList");
CheckProperties (transform);
transform = new UnprotectedXmlDsigExcC14NTransform (false, "#default xsd");
- AssertEquals ("Algorithm", "http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm);
- AssertEquals ("InclusiveNamespacesPrefixList", "#default xsd", transform.InclusiveNamespacesPrefixList);
+ Assert.AreEqual ("http://www.w3.org/2001/10/xml-exc-c14n#", transform.Algorithm, "Algorithm");
+ Assert.AreEqual ("#default xsd", transform.InclusiveNamespacesPrefixList, "InclusiveNamespacesPrefixList");
CheckProperties (transform);
}
void CheckProperties (XmlDsigExcC14NTransform transform)
{
Type[] input = transform.InputTypes;
- Assert ("Input #", (input.Length == 3));
+ Assert.IsTrue ((input.Length == 3), "Input #");
// check presence of every supported input types
bool istream = false;
bool ixmldoc = false;
if (t.ToString () == "System.Xml.XmlNodeList")
ixmlnl = true;
}
- Assert ("Input Stream", istream);
- Assert ("Input XmlDocument", ixmldoc);
- Assert ("Input XmlNodeList", ixmlnl);
+ Assert.IsTrue (istream, "Input Stream");
+ Assert.IsTrue (ixmldoc, "Input XmlDocument");
+ Assert.IsTrue (ixmlnl, "Input XmlNodeList");
Type[] output = transform.OutputTypes;
- Assert ("Output #", (output.Length == 1));
+ Assert.IsTrue ((output.Length == 1), "Output #");
// check presence of every supported output types
bool ostream = false;
foreach (Type t in output) {
if (t.ToString () == "System.IO.Stream")
ostream = true;
}
- Assert ("Output Stream", ostream);
+ Assert.IsTrue (ostream, "Output Stream");
}
[Test]
input [2] = null;
// property does not return a clone
foreach (Type t in transform.InputTypes) {
- AssertNull (t);
+ Assert.IsNull (t);
}
// it's not a static array
XmlDsigExcC14NTransform t2 = new XmlDsigExcC14NTransform ();
foreach (Type t in t2.InputTypes) {
- AssertNotNull (t);
+ Assert.IsNotNull (t);
}
}
public void GetInnerXml ()
{
XmlNodeList xnl = transform.UnprotectedGetInnerXml ();
- AssertNull ("Default InnerXml", xnl);
+ Assert.IsNull (xnl, "Default InnerXml");
}
private string Stream2String (Stream s)
Stream s = (Stream) transform.GetOutput ();
string output = Stream2String (s);
#if NET_1_1
- AssertEquals("XmlDocument", c14xml3, output);
+ Assert.AreEqual (c14xml3, output, "XmlDocument");
#else
// .NET 1.0 keeps the \r\n (0x0D, 0x0A) - bug
- AssertEquals("XmlDocument", c14xml1, output);
+ Assert.AreEqual (c14xml1, output, "XmlDocument");
#endif
}
transform.LoadInput (doc.ChildNodes);
Stream s = (Stream) transform.GetOutput ();
string output = Stream2String (s);
- AssertEquals ("XmlChildNodes", "<Test></Test>", output);
+ Assert.AreEqual ("<Test></Test>", output, "XmlChildNodes");
}
[Test]
Stream s = (Stream) transform.GetOutput ();
string output = Stream2String (s);
string expected = @"<Test><Toto></Toto></Test>";
- AssertEquals ("XmlChildNodes", expected, output);
+ Assert.AreEqual (expected, output, "XmlChildNodes");
}
[Test]
transform.LoadInput (ms);
Stream s = (Stream) transform.GetOutput ();
string output = Stream2String (s);
- AssertEquals ("MemoryStream", c14xml2, output);
+ Assert.AreEqual (c14xml2, output, "MemoryStream");
}
[Test]
sw.Close ();
}
string res = ExecuteXmlDSigExcC14NTransform (ExcC14NSpecExample1Input);
- AssertEquals ("Example 1 from c14n spec - PIs, Comments, and Outside of Document Element (without comments)",
- ExcC14NSpecExample1Output, res);
+ Assert.AreEqual (ExcC14NSpecExample1Output, res, "Example 1 from c14n spec - PIs, Comments, and Outside of Document Element (without comments)");
}
[Test]
public void ExcC14NSpecExample2 ()
{
string res = ExecuteXmlDSigExcC14NTransform (ExcC14NSpecExample2Input);
- AssertEquals ("Example 2 from c14n spec - Whitespace in Document Content (without comments)",
- ExcC14NSpecExample2Output, res);
+ Assert.AreEqual (ExcC14NSpecExample2Output, res, "Example 2 from c14n spec - Whitespace in Document Content (without comments)");
}
[Test]
public void ExcC14NSpecExample3 ()
{
string res = ExecuteXmlDSigExcC14NTransform (ExcC14NSpecExample3Input);
- AssertEquals ("Example 3 from c14n spec - Start and End Tags (without comments)",
- ExcC14NSpecExample3Output, res);
+ Assert.AreEqual (ExcC14NSpecExample3Output, res, "Example 3 from c14n spec - Start and End Tags (without comments)");
}
[Test]
public void ExcC14NSpecExample4 ()
{
string res = ExecuteXmlDSigExcC14NTransform (ExcC14NSpecExample4Input);
- AssertEquals ("Example 4 from c14n spec - Character Modifications and Character References (without comments)",
- ExcC14NSpecExample4Output, res);
+ Assert.AreEqual (ExcC14NSpecExample4Output, res, "Example 4 from c14n spec - Character Modifications and Character References (without comments)");
}
[Test]
sw.Close ();
}
string res = ExecuteXmlDSigExcC14NTransform (ExcC14NSpecExample5Input);
- AssertEquals ("Example 5 from c14n spec - Entity References (without comments)",
- ExcC14NSpecExample5Output, res);
+ Assert.AreEqual (ExcC14NSpecExample5Output, res, "Example 5 from c14n spec - Entity References (without comments)");
}
[Test]
public void ExcC14NSpecExample6 ()
{
string res = ExecuteXmlDSigExcC14NTransform (ExcC14NSpecExample6Input);
- AssertEquals ("Example 6 from c14n spec - UTF-8 Encoding (without comments)",
- ExcC14NSpecExample6Output, res);
+ Assert.AreEqual (ExcC14NSpecExample6Output, res, "Example 6 from c14n spec - UTF-8 Encoding (without comments)");
}
private string ExecuteXmlDSigExcC14NTransform (string InputXml)
XmlDsigExcC14NTransform t = new XmlDsigExcC14NTransform ();
t.LoadInput (doc);
Stream s = t.GetOutput () as Stream;
- AssertEquals (expected, new StreamReader (s, Encoding.UTF8).ReadToEnd ());
+ Assert.AreEqual (new StreamReader (s, Encoding.UTF8).ReadToEnd (), expected);
}
[Test]
}
[TestFixture]
- public class XmlDsigXPathTransformTest : Assertion {
+ public class XmlDsigXPathTransformTest {
protected UnprotectedXmlDsigXPathTransform transform;
[Test]
public void Properties ()
{
- AssertEquals ("Algorithm", "http://www.w3.org/TR/1999/REC-xpath-19991116", transform.Algorithm);
+ Assert.AreEqual ("http://www.w3.org/TR/1999/REC-xpath-19991116", transform.Algorithm, "Algorithm");
Type[] input = transform.InputTypes;
- Assert ("Input #", (input.Length == 3));
+ Assert.IsTrue ((input.Length == 3), "Input #");
// check presence of every supported input types
bool istream = false;
bool ixmldoc = false;
if (t.ToString () == "System.Xml.XmlNodeList")
ixmlnl = true;
}
- Assert ("Input Stream", istream);
- Assert ("Input XmlDocument", ixmldoc);
- Assert ("Input XmlNodeList", ixmlnl);
+ Assert.IsTrue (istream, "Input Stream");
+ Assert.IsTrue (ixmldoc, "Input XmlDocument");
+ Assert.IsTrue (ixmlnl, "Input XmlNodeList");
Type[] output = transform.OutputTypes;
- Assert ("Output #", (output.Length == 1));
+ Assert.IsTrue ((output.Length == 1), "Output #");
// check presence of every supported output types
bool oxmlnl = false;
foreach (Type t in output) {
if (t.ToString () == "System.Xml.XmlNodeList")
oxmlnl = true;
}
- Assert ("Output XmlNodeList", oxmlnl);
+ Assert.IsTrue (oxmlnl, "Output XmlNodeList");
}
- protected void AssertEquals (string msg, XmlNodeList expected, XmlNodeList actual)
+ protected void AreEqual (string msg, XmlNodeList expected, XmlNodeList actual)
{
for (int i=0; i < expected.Count; i++) {
if (expected [i].OuterXml != actual [i].OuterXml)
- Fail (msg + " [" + i + "] expected " + expected[i].OuterXml + " bug got " + actual[i].OuterXml);
+ Assert.Fail (msg + " [" + i + "] expected " + expected[i].OuterXml + " bug got " + actual[i].OuterXml);
}
- AssertEquals (expected.Count, actual.Count);
+ Assert.AreEqual (expected.Count, actual.Count);
}
[Test]
public void GetInnerXml ()
{
XmlNodeList xnl = transform.UnprotectedGetInnerXml ();
- AssertEquals ("Default InnerXml.Count", 1, xnl.Count);
- AssertEquals ("Default InnerXml.OuterXml", "<XPath xmlns=\"http://www.w3.org/2000/09/xmldsig#\"></XPath>", xnl [0].OuterXml);
+ Assert.AreEqual (1, xnl.Count, "Default InnerXml.Count");
+ Assert.AreEqual ("<XPath xmlns=\"http://www.w3.org/2000/09/xmldsig#\"></XPath>", xnl [0].OuterXml, "Default InnerXml.OuterXml");
}
[Test]
transform.LoadInnerXml (inner);
XmlNodeList xnl = (XmlNodeList) transform.GetOutput ();
#if NET_2_0
- AssertEquals ("Count", 0, xnl.Count);
+ Assert.AreEqual (0, xnl.Count, "Count");
#endif
}
transform.LoadInnerXml (inner);
XmlNodeList xnl = (XmlNodeList) transform.GetOutput ();
#if NET_2_0
- AssertEquals (73, xnl.Count);
+ Assert.AreEqual (73, xnl.Count);
#else
- AssertEquals (47, xnl.Count);
+ Assert.AreEqual (47, xnl.Count);
#endif
}
transform.LoadInput (doc);
// empty means no LoadInnerXml
XmlNodeList xnl = (XmlNodeList) transform.GetOutput ();
- AssertEquals ("Empy Result", 0, xnl.Count);
+ Assert.AreEqual (0, xnl.Count, "Empy Result");
}
[Test]
XmlNodeList inner = InnerXml ("//*/title");
transform.LoadInnerXml (inner);
XmlNodeList xnl = (XmlNodeList) transform.GetOutput ();
- AssertEquals (1, xnl.Count);
+ Assert.AreEqual (1, xnl.Count);
}
[Test]
transform.LoadInput (doc.ChildNodes);
// empty means no LoadInnerXml
XmlNodeList xnl = (XmlNodeList) transform.GetOutput ();
- AssertEquals ("Empy Result", 0, xnl.Count);
+ Assert.AreEqual (0, xnl.Count, "Empy Result");
}
[Test]
transform.LoadInnerXml (inner);
XmlNodeList xnl = (XmlNodeList) transform.GetOutput ();
#if NET_2_0
- AssertEquals (73, xnl.Count);
+ Assert.AreEqual (73, xnl.Count);
#else
- AssertEquals (47, xnl.Count);
+ Assert.AreEqual (47, xnl.Count);
#endif
}
transform.LoadInput (ms);
// empty means no LoadInnerXml
XmlNodeList xnl = (XmlNodeList) transform.GetOutput ();
- AssertEquals ("Empy Result", 0, xnl.Count);
+ Assert.AreEqual (0, xnl.Count, "Empy Result");
}
[Test]
XmlNodeList inner = InnerXml ("//*");
transform.LoadInnerXml (inner);
XmlNodeList xnl = transform.UnprotectedGetInnerXml ();
- AssertEquals ("LoadInnerXml", inner, xnl);
+ Assert.AreEqual (inner, xnl, "LoadInnerXml");
}
[Test]
doc.LoadXml ("<element xmlns='urn:foo'><foo><bar>test</bar></foo></element>");
t.LoadInput (doc);
XmlNodeList nl = (XmlNodeList) t.GetOutput ();
- AssertEquals (XmlNodeType.Document, nl [0].NodeType);
- AssertEquals (XmlNodeType.Element, nl [1].NodeType);
- AssertEquals ("element", nl [1].LocalName);
- AssertEquals (XmlNodeType.Element, nl [2].NodeType);
- AssertEquals ("foo", nl [2].LocalName);
- AssertEquals (XmlNodeType.Element, nl [3].NodeType);
- AssertEquals ("bar", nl [3].LocalName);
+ Assert.AreEqual (XmlNodeType.Document, nl [0].NodeType);
+ Assert.AreEqual (XmlNodeType.Element, nl [1].NodeType);
+ Assert.AreEqual ("element", nl [1].LocalName);
+ Assert.AreEqual (XmlNodeType.Element, nl [2].NodeType);
+ Assert.AreEqual ("foo", nl [2].LocalName);
+ Assert.AreEqual (XmlNodeType.Element, nl [3].NodeType);
+ Assert.AreEqual ("bar", nl [3].LocalName);
// MS.NET bug - ms.net returns ns node even when the
// current node is ns node (it is like returning
// attribute from attribute nodes).
-// AssertEquals (XmlNodeType.Attribute, nl [4].NodeType);
-// AssertEquals ("xmlns", nl [4].LocalName);
+// Assert.AreEqual (XmlNodeType.Attribute, nl [4].NodeType);
+// Assert.AreEqual ("xmlns", nl [4].LocalName);
}
[Test]
t.LoadInput (doc);
XmlNodeList nl = (XmlNodeList) t.GetOutput ();
- AssertEquals ("0", 0, nl.Count);
+ Assert.AreEqual (0, nl.Count, "0");
doc.LoadXml ("<element xmlns='urn:foo'><foo><bar>test</bar></foo></element>");
t.LoadInput (doc);
nl = (XmlNodeList) t.GetOutput ();
#if NET_2_0
- AssertEquals ("1", 0, nl.Count);
+ Assert.AreEqual (0, nl.Count, "1");
#else
- AssertEquals ("1", 1, nl.Count);
+ Assert.AreEqual (1, nl.Count, "1");
#endif
doc.LoadXml ("<element xmlns='urn:foo'><foo xmlns='urn:bar'><bar>test</bar></foo></element>");
t.LoadInput (doc);
nl = (XmlNodeList) t.GetOutput ();
#if NET_2_0
- AssertEquals ("2", 0, nl.Count);
+ Assert.AreEqual (0, nl.Count, "2");
#else
- AssertEquals ("2", 2, nl.Count);
+ Assert.AreEqual (2, nl.Count, "2");
#endif
doc.LoadXml ("<element xmlns='urn:foo' xmlns:x='urn:x'><foo xmlns='urn:bar'><bar>test</bar></foo></element>");
t.LoadInput (doc);
nl = (XmlNodeList) t.GetOutput ();
#if NET_2_0
- AssertEquals ("3", 0, nl.Count);
+ Assert.AreEqual (0, nl.Count, "3");
#else
- AssertEquals ("3", 3, nl.Count);
+ Assert.AreEqual (3, nl.Count, "3");
#endif
doc.LoadXml ("<envelope><Signature xmlns='http://www.w3.org/2000/09/xmldsig#'><XPath>blah</XPath></Signature></envelope>");
t.LoadInput (doc);
nl = (XmlNodeList) t.GetOutput ();
#if NET_2_0
- AssertEquals ("4", 0, nl.Count);
+ Assert.AreEqual (0, nl.Count, "4");
#else
- AssertEquals ("4", 1, nl.Count);
- AssertEquals ("NodeType", XmlNodeType.Attribute, nl [0].NodeType);
+ Assert.AreEqual (1, nl.Count, "4");
+ Assert.AreEqual (XmlNodeType.Attribute, nl [0].NodeType, "NodeType");
#endif
}
}
}
[TestFixture]
- public class XmlDsigXsltTransformTest : Assertion {
+ public class XmlDsigXsltTransformTest {
protected UnprotectedXmlDsigXsltTransform transform;
void CheckProperties (XmlDsigXsltTransform transform)
{
- AssertEquals ("Algorithm", "http://www.w3.org/TR/1999/REC-xslt-19991116", transform.Algorithm);
+ Assert.AreEqual ("http://www.w3.org/TR/1999/REC-xslt-19991116", transform.Algorithm, "Algorithm");
Type[] input = transform.InputTypes;
- Assert ("Input #", (input.Length == 3));
+ Assert.IsTrue ((input.Length == 3), "Input #");
// check presence of every supported input types
bool istream = false;
bool ixmldoc = false;
if (t.ToString () == "System.Xml.XmlNodeList")
ixmlnl = true;
}
- Assert ("Input Stream", istream);
- Assert ("Input XmlDocument", ixmldoc);
- Assert ("Input XmlNodeList", ixmlnl);
+ Assert.IsTrue (istream, "Input Stream");
+ Assert.IsTrue (ixmldoc, "Input XmlDocument");
+ Assert.IsTrue (ixmlnl, "Input XmlNodeList");
Type[] output = transform.OutputTypes;
- Assert ("Output #", (output.Length == 1));
+ Assert.IsTrue ((output.Length == 1), "Output #");
// check presence of every supported output types
bool ostream = false;
foreach (Type t in output) {
if (t.ToString () == "System.IO.Stream")
ostream = true;
}
- Assert ("Output Stream", ostream);
+ Assert.IsTrue (ostream, "Output Stream");
}
[Test]
public void GetInnerXml ()
{
XmlNodeList xnl = transform.UnprotectedGetInnerXml ();
- AssertNull ("Default InnerXml", xnl);
+ Assert.IsNull (xnl, "Default InnerXml");
}
private string Stream2Array (Stream s)
#endif
}
finally {
- Assert ("Exception not thrown", result);
+ Assert.IsTrue (result, "Exception not thrown");
}
}
string output = Stream2Array (s);
}
- protected void AssertEquals (string msg, XmlNodeList expected, XmlNodeList actual)
+ protected void AreEqual (string msg, XmlNodeList expected, XmlNodeList actual)
{
for (int i=0; i < expected.Count; i++) {
if (expected[i].OuterXml != actual[i].OuterXml)
- Fail (msg + " [" + i + "] expected " + expected[i].OuterXml + " bug got " + actual[i].OuterXml);
+ Assert.Fail (msg + " [" + i + "] expected " + expected[i].OuterXml + " bug got " + actual[i].OuterXml);
}
}
XmlDocument doc = GetXslDoc ();
transform.LoadInnerXml (doc.DocumentElement.ChildNodes);
XmlNodeList xnl = transform.UnprotectedGetInnerXml ();
- AssertEquals ("LoadInnerXml", doc.DocumentElement.ChildNodes, xnl);
+ Assert.AreEqual (doc.DocumentElement.ChildNodes, xnl, "LoadInnerXml");
}
[Test]
projects / mono.git / commitdiff