private static string Encode(string s)
{
return
(Base32Convert.ToBase32HexString(Encoding.UTF7.GetBytes(s),
Base32FormattingOptions.
InsertTrailingPadding));
}
private static string DecodeOmitPadding(string s)
{
byte[] bytes =
Base32Convert.FromBase32HexString(s,
Base32FormattingOptions.
None);
return(Encoding.UTF7.GetString(bytes));
}
public void Given_Base32Converter_When_ABase32StringIsConvertedToByteArray_Then_CorrectDataIsReturned(
String expected,
String base32String)
{
var result = Base32Convert.FromBase32String(base32String);
Assert.Equal(expected, Encoding.UTF8.GetString(result));
}
private static string Decode(string s)
{
byte[] bytes =
Base32Convert.FromBase32HexString(s,
Base32FormattingOptions.
InsertTrailingPadding);
return(Encoding.UTF7.GetString(bytes));
}
public void Given_Base32Converter_When_NullBase32StringIsConvertedToByteArray_Then_ResultIsNull()
{
var base32String = default(String);
var result = Base32Convert.FromBase32String(base32String);
Assert.Null(result);
}
public void Given_Base32Converter_When_AStringInUTF8IsConvertedToBase32StringWithoutPadding_Then_ResultIsCorrect(String input, String expected)
{
var applyPadding = false;
var result = Base32Convert.ToBase32String(Encoding.UTF8.GetBytes(input), applyPadding);
Assert.Equal(expected, result);
}
public void ToStringTest()
{
var expected = "6Q======";
var data = new byte[] { 244 };
var actual = Base32Convert.ToString(data);
Assert.Equal(expected, actual);
}
public void ToBytesByteArrayTest()
{
var baseNCharBytes = "6Q======".ToCharArray().Select(ch => (byte)ch).ToArray();
var expected = new byte[] { 244 };
var actual = Base32Convert.ToBytes(baseNCharBytes);
Assert.Equal(expected, actual);
}
public void ToBytesCharArrayPartialTest()
{
var baseNChars = "996Q======99".ToCharArray();
var expected = new byte[] { 244 };
var actual = Base32Convert.ToBytes(baseNChars, 2, baseNChars.Length - 4);
Assert.Equal(expected, actual);
}
public void ToBytesCharArrayTest()
{
var baseNChars = "6Q======".ToCharArray();
var expected = new byte[] { 244 };
var actual = Base32Convert.ToBytes(baseNChars);
Assert.Equal(expected, actual);
}
public void ToCharArrayPartialTest()
{
var expected = "6Q======".ToCharArray();
var data = new byte[] { 255, 244, 255 };
var actual = Base32Convert.ToCharArray(data, 1, 1);
Assert.Equal(expected, actual);
}
public void ToCharArrayTest()
{
var expected = "6Q======".ToCharArray();
var data = new byte[] { 244 };
var actual = Base32Convert.ToCharArray(data);
Assert.Equal(expected, actual);
}
public void ToStringPartialTest()
{
var expected = "6Q======";
var data = new byte[] { 255, 244, 255 };
var actual = Base32Convert.ToString(data, 1, 1);
Assert.Equal(expected, actual);
}
public void ToBytesStringPartialTest()
{
var baseNString = "996Q======99";
var expected = new byte[] { 244 };
var actual = Base32Convert.ToBytes(baseNString, 2, baseNString.Length - 4);
Assert.Equal(expected, actual);
}
public void ToByteStringTest()
{
var baseNString = "6Q======";
var expected = new byte[] { 244 };
var actual = Base32Convert.ToBytes(baseNString);
Assert.Equal(expected, actual);
}
public void ToBytesByteArrayPartialTest()
{
var baseNCharBytes = "996Q======99".ToCharArray().Select(ch => (byte)ch).ToArray();
var expected = new byte[] { 244 };
var actual = Base32Convert.ToBytes(baseNCharBytes, 2, baseNCharBytes.Length - 4);
Assert.Equal(expected, actual);
}
public void Given_Base32Converter_When_EmptyArrayIsConvertedToBase32StringWithoutPadding_Then_ResultIsEmpty()
{
var input = new byte[0];
var applyPadding = false;
var result = Base32Convert.ToBase32String(input, applyPadding);
Assert.Equal(String.Empty, result);
}
public void Given_Base32Converter_When_NullArrayIsConvertedToBase32StringWithoutPadding_Then_ResultIsNull()
{
var input = default(byte[]);
var applyPadding = false;
var result = Base32Convert.ToBase32String(input, applyPadding);
Assert.Null(result);
}
Given_Base32Converter_When_AStringInUTF8IsConvertedToBase32StringWithoutPaddingAndBack_Then_ItIsTheSameAsTheOriginalString(
String input)
{
var applyPadding = false;
var base32 = Base32Convert.ToBase32String(Encoding.UTF8.GetBytes(input), applyPadding);
var result = Base32Convert.FromBase32String(base32);
Assert.Equal(input, Encoding.UTF8.GetString(result));
}
static public void EncodeThenDecodeNoPadding(IEnumerator[] a)
{
List <byte> octets = new List <byte>();
for (int j = 1; j < a.Length; j++)
{
octets.Add((byte)a[j].Current);
}
byte[] result = Base32Convert.FromBase32String(Base32Convert.ToBase32String(octets, Base32FormattingOptions.None), Base32FormattingOptions.None);
Assert.IsTrue(SameContent(result, octets, Comparer <byte> .Default));
}
private static string EncodeOmitPadding(string s)
{
return
(Base32Convert.ToBase32HexString(Encoding.UTF7.GetBytes(s),
Base32FormattingOptions.None));
}
public void EncodeOmitPadding_null_throws()
{
Assert.Throws <ArgumentNullException>(
() => Base32Convert.ToBase32HexString(null, Base32FormattingOptions.None));
}
public void Encode_null_throws()
{
Assert.Throws <ArgumentNullException>(
() => Base32Convert.ToBase32HexString(null, Base32FormattingOptions.InsertTrailingPadding));
}
public void DecodeOmitPadding_PaddingCharacter_throws()
{
Assert.Throws <ArgumentException>(
() => Base32Convert.FromBase32HexString("my======", Base32FormattingOptions.None));
}
public void DecodeOmitPadding_CharacterNotInAlphabet_throws()
{
Assert.Throws <ArgumentException>(
() => Base32Convert.FromBase32HexString("#y", Base32FormattingOptions.None));
}
public void Decode_WrongNumberOfPaddingCharacters_throws()
{
Assert.Throws <ArgumentException>(
() => Base32Convert.FromBase32HexString("my=====", Base32FormattingOptions.InsertTrailingPadding));
}
public void DecodeOmitPadding_WrongNumberOfCharacters_6_throws()
{
Assert.Throws <ArgumentException>(
() => Base32Convert.FromBase32HexString("123456", Base32FormattingOptions.None));
}
public void Decode_MisplacedPaddingCharacter_throws()
{
Assert.Throws <ArgumentException>(
() => Base32Convert.FromBase32HexString("m=y======", Base32FormattingOptions.InsertTrailingPadding)
);
}
public void Decode_CharacterNotInAlphabet_throws()
{
Assert.Throws <ArgumentException>(
() => Base32Convert.FromBase32HexString("#y======", Base32FormattingOptions.InsertTrailingPadding)
);
}
/// <summary>
/// Annotate an xml document with a sort key suitable for xslt version 1 sorting algorithms (use lang='en')
/// </summary>
/// <param name="document">input to add sort keys to</param>
/// <param name="xpathSortKeySource">an xpath that selects the source to use to create a sort key</param>
/// <param name="sortKeyGenerator">delegate that returns a SortKey given a string</param>
/// <param name="xpathElementToPutSortKeyAttributeIn">a relative xpath (from the source) that selects the element to put the sortkey attribute in</param>
/// <param name="prefix">The prefix of the sort-key attribute</param>
/// <param name="attribute">The sort key attribute</param>
/// <param name="namespaceUri">The namespace of the sortkey attribute</param>
public static void AddSortKeys(
XPathNavigator document,
string xpathSortKeySource,
SortKeyGenerator sortKeyGenerator,
string xpathElementToPutSortKeyAttributeIn,
string prefix,
string attribute,
string namespaceUri)
{
if (document == null)
{
throw new ArgumentNullException("document");
}
if (xpathSortKeySource == null)
{
throw new ArgumentNullException("xpathSortKeySource");
}
if (sortKeyGenerator == null)
{
throw new ArgumentNullException("sortKeyGenerator");
}
if (xpathElementToPutSortKeyAttributeIn == null)
{
throw new ArgumentNullException("xpathElementToPutSortKeyAttributeIn");
}
if (attribute == null)
{
throw new ArgumentNullException("attribute");
}
if (prefix != null | namespaceUri != null) // if both are null it's okay but if only one it's an error
{
if (prefix == null)
{
throw new ArgumentNullException("prefix");
}
if (prefix.Length == 0)
{
throw new ArgumentException("Invalid prefix. Prefix cannot be empty.");
}
if (namespaceUri == null)
{
throw new ArgumentNullException("prefix");
}
if (namespaceUri.Length == 0)
{
throw new ArgumentException("Invalid namespace URI. Cannot be empty.");
}
}
XPathExpression compiledXpathElementToPutSortKeyAttributeIn =
XPathExpression.Compile(xpathElementToPutSortKeyAttributeIn);
foreach (XPathNavigator sortKeySource in document.Select(xpathSortKeySource))
{
byte[] sortKeyData = sortKeyGenerator(sortKeySource.Value).KeyData;
string sortKeyBase32 = Base32Convert.ToBase32HexString(sortKeyData, Base32FormattingOptions.None);
XPathNavigator elementToPutSortKeyAttributeIn =
sortKeySource.SelectSingleNode(compiledXpathElementToPutSortKeyAttributeIn);
if (elementToPutSortKeyAttributeIn.MoveToAttribute(attribute, namespaceUri ?? string.Empty))
{
//now we point at the attribute that already exists
elementToPutSortKeyAttributeIn.DeleteSelf();
}
elementToPutSortKeyAttributeIn.CreateAttribute(prefix,
attribute,
namespaceUri,
sortKeyBase32);
}
}
