| private GetBytes ( char chars, int charCount, byte bytes, int byteCount ) : int | ||
| chars | char | |
| charCount | int | |
| bytes | byte | |
| byteCount | int | |
| Результат | int | |
public void PosTest2()
{
Byte[] bytes;
Char[] chars = new Char[] { };
UTF7Encoding UTF7 = new UTF7Encoding();
int byteCount = UTF7.GetByteCount(chars, 0, 0);
bytes = new Byte[byteCount];
int bytesEncodedCount = UTF7.GetBytes(chars, 0, 0, bytes, 0);
Assert.Equal(0, bytesEncodedCount);
}
protected byte[] Decode7Bit(string value)
{
try
{
UTF7Encoding utf7 = new UTF7Encoding();
return utf7.GetBytes(value);
}
catch
{
return null;
}
}
public void NegTest1()
{
Byte[] bytes;
Char[] chars = null;
UTF7Encoding UTF7 = new UTF7Encoding();
int byteCount = 10;
bytes = new Byte[byteCount];
Assert.Throws<ArgumentNullException>(() =>
{
int bytesEncodedCount = UTF7.GetBytes(chars, 1, 2, bytes, 0);
});
}
public void PosTest1()
{
Byte[] bytes;
Char[] chars = new Char[] {
'\u0023',
'\u0025',
'\u03a0',
'\u03a3' };
UTF7Encoding UTF7 = new UTF7Encoding();
int byteCount = UTF7.GetByteCount(chars, 1, 2);
bytes = new Byte[byteCount];
int bytesEncodedCount = UTF7.GetBytes(chars, 1, 2, bytes, 0);
}
public void NegTest2()
{
Byte[] bytes;
Char[] chars = new Char[] {
'\u0023',
'\u0025',
'\u03a0',
'\u03a3' };
UTF7Encoding UTF7 = new UTF7Encoding();
int byteCount = UTF7.GetByteCount(chars, 1, 2);
bytes = null;
Assert.Throws<ArgumentNullException>(() =>
{
int bytesEncodedCount = UTF7.GetBytes(chars, 1, 2, bytes, 0);
});
}
public void TestDirectlyEncoded1()
{
// Unicode characters a-z, A-Z, 0-9 and '()_./:? are directly encoded.
string UniCodeString = "\u0061\u007A\u0041\u005A\u0030\u0039\u0027\u003F";
byte[] UTF7Bytes = null;
UTF7Encoding UTF7enc = new UTF7Encoding ();
UTF7Bytes = UTF7enc.GetBytes (UniCodeString);
Assertion.AssertEquals ("UTF7 #1", 0x61, UTF7Bytes [0]);
Assertion.AssertEquals ("UTF7 #2", 0x7A, UTF7Bytes [1]);
Assertion.AssertEquals ("UTF7 #3", 0x41, UTF7Bytes [2]);
Assertion.AssertEquals ("UTF7 #4", 0x5A, UTF7Bytes [3]);
Assertion.AssertEquals ("UTF7 #5", 0x30, UTF7Bytes [4]);
Assertion.AssertEquals ("UTF7 #6", 0x39, UTF7Bytes [5]);
Assertion.AssertEquals ("UTF7 #7", 0x27, UTF7Bytes [6]);
Assertion.AssertEquals ("UTF7 #8", 0x3F, UTF7Bytes [7]);
}
public void TestDirectlyEncoded2()
{
// Unicode characters a-z, A-Z, 0-9 and '()_./:? are directly encoded.
string UniCodeString = "\u0061\u007A\u0041\u005A\u0030\u0039\u0027\u003F";
byte[] UTF7Bytes = new byte [8];
int Length = UniCodeString.Length;
UTF7Encoding UTF7enc = new UTF7Encoding ();
int Cnt = UTF7enc.GetBytes (UniCodeString.ToCharArray(), 0, Length, UTF7Bytes, 0);
Assert.AreEqual (0x61, UTF7Bytes [0], "UTF7 #1");
Assert.AreEqual (0x7A, UTF7Bytes [1], "UTF7 #2");
Assert.AreEqual (0x41, UTF7Bytes [2], "UTF7 #3");
Assert.AreEqual (0x5A, UTF7Bytes [3], "UTF7 #4");
Assert.AreEqual (0x30, UTF7Bytes [4], "UTF7 #5");
Assert.AreEqual (0x39, UTF7Bytes [5], "UTF7 #6");
Assert.AreEqual (0x27, UTF7Bytes [6], "UTF7 #7");
Assert.AreEqual (0x3F, UTF7Bytes [7], "UTF7 #8");
}
public void TestEncodeOptionalEncoded()
{
string UniCodeString = "\u0021\u0026\u002A\u003B";
byte[] UTF7Bytes = null;
//Optional Characters are allowed.
UTF7Encoding UTF7enc = new UTF7Encoding (true);
UTF7Bytes = UTF7enc.GetBytes (UniCodeString);
Assertion.AssertEquals ("UTF7 #1", 0x21, UTF7Bytes [0]);
Assertion.AssertEquals ("UTF7 #2", 0x26, UTF7Bytes [1]);
Assertion.AssertEquals ("UTF7 #3", 0x2A, UTF7Bytes [2]);
Assertion.AssertEquals ("UTF7 #4", 0x3B, UTF7Bytes [3]);
//Optional characters are not allowed.
UTF7enc = new UTF7Encoding (false);
UTF7Bytes = UTF7enc.GetBytes (UniCodeString);
Assertion.AssertEquals ("UTF7 #5", 0x2B, UTF7Bytes [0]);
Assertion.AssertEquals ("UTF7 #6", 0x41, UTF7Bytes [1]);
Assertion.AssertEquals ("UTF7 #7", 0x43, UTF7Bytes [2]);
Assertion.AssertEquals ("UTF7 #8", 0x45, UTF7Bytes [3]);
Assertion.AssertEquals ("UTF7 #6", 0x41, UTF7Bytes [1]);
}
//-------------------------------------------------------------------------------
// Name : GetUniStrRandAnsiBytes
// Purpose : This function returns a Byte array of Unicode,UTF7 or UTF8 characters.
// Inputs : iMaxChar -- maximum number of character to be generated
// : bAbsolute -- if set true, exact number (iMaxChar) will be generated,
// if set falise, number of generated chars will be random.
// : bValidate -- boolean, if true, verify generated characters are valid
// if false, does not verify generated characters
// : intType -- Type of conversion to make. CODE_UNI, CODE_UTF7, CODE_UTF8.
// Note : enulcidType -- Locale ID.
//-------------------------------------------------------------------------------
public Byte[] GetUniStrRandAnsiBytes(int iMaxChar, bool bAbsolute, bool bValidate, enuCodeType intCodeType, enuLCIDList enulcidType, bool bNoLeadNum ){
String strText;
Byte[] bArrEncoded = null;
int iOldLCID = iCurrentLCID ;
VerifyLCIDAndLoadResource( (int)enulcidType );
if ( iMaxChar <= 0 ) // If the string length is <= zero, return an empty string
return bArrEncoded;
if ((int)intCodeType < 0 || (int)intCodeType > 3) // invalid conversion type
intCodeType = enuCodeType.CURRENT; //use default system code page.
strText = GetString( iMaxChar, bAbsolute, bValidate );
switch( intCodeType ){
case enuCodeType.CODE_UTF8:
UTF8Encoding encUTF8 = new UTF8Encoding();
bArrEncoded = encUTF8.GetBytes( strText );
break ;
case enuCodeType.CODE_UTF7:
UTF7Encoding encUTF7 = new UTF7Encoding();
bArrEncoded = encUTF7.GetBytes( strText );
break ;
case enuCodeType.CODE_UNI:
UnicodeEncoding encUnicode = new UnicodeEncoding();
bArrEncoded = encUnicode.GetBytes( strText );
break ;
case enuCodeType.CURRENT: //In case if you need the encoding bytes for default system code page.
Encoding encode = Encoding.Default;
bArrEncoded = encode.GetBytes( strText );
break;
default:
break ;
}
VerifyLCIDAndLoadResource( iOldLCID );
return bArrEncoded ;
}
public void WriteUDTString(string tagName, string value)
{
lock (mSyncLock) {
Logix.Tag lengthTag = new Logix.Tag(tagName + ".LEN");
Logix.Tag dataTag = new Logix.Tag(tagName + ".DATA[0]");
System.Text.UTF7Encoding utf = new System.Text.UTF7Encoding();
// * set the DataType properties
lengthTag.DataType = Logix.Tag.ATOMIC.DINT;
dataTag.DataType = Logix.Tag.ATOMIC.SINT;
lengthTag.Value = value.Length;
dataTag.Length = value.Length;
dataTag.Value = utf.GetBytes(value);
WriteTag(lengthTag);
WriteTag(dataTag);
}
}
public void TestEncodeUnicodeShifted1()
{
string UniCodeString = "\u0041\u2262\u0391\u002E";
byte[] UTF7Bytes = null;
UTF7Encoding UTF7enc = new UTF7Encoding();
UTF7Bytes = UTF7enc.GetBytes (UniCodeString);
//"A<NOT IDENTICAL TO><ALPHA>." is encoded as A+ImIDkQ-. see RFC 1642
Assertion.AssertEquals ("UTF7 #1", 0x41, UTF7Bytes [0]);
Assertion.AssertEquals ("UTF7 #2", 0x2B, UTF7Bytes [1]);
Assertion.AssertEquals ("UTF7 #3", 0x49, UTF7Bytes [2]);
Assertion.AssertEquals ("UTF7 #4", 0x6D, UTF7Bytes [3]);
Assertion.AssertEquals ("UTF7 #5", 0x49, UTF7Bytes [4]);
Assertion.AssertEquals ("UTF7 #6", 0x44, UTF7Bytes [5]);
Assertion.AssertEquals ("UTF7 #7", 0x6B, UTF7Bytes [6]);
Assertion.AssertEquals ("UTF7 #8", 0x51, UTF7Bytes [7]);
Assertion.AssertEquals ("UTF7 #9", 0x2D, UTF7Bytes [8]);
Assertion.AssertEquals ("UTF7 #10", 0x2E, UTF7Bytes [9]);
}
public override int GetBytes(char[] chars, int charIndex, int charCount,
byte[] bytes, int byteIndex, bool flush)
{
return(encoding.GetBytes(chars, charIndex, charCount,
bytes, byteIndex, flush, this));
}
public void TestEncodeUnicodeShifted2()
{
string UniCodeString = "\u0041\u2262\u0391\u002E";
byte[] UTF7Bytes = new byte [10];
int Length = UniCodeString.Length;
UTF7Encoding UTF7enc = new UTF7Encoding ();
int Cnt = UTF7enc.GetBytes (UniCodeString.ToCharArray(), 0, Length, UTF7Bytes, 0);
//"A<NOT IDENTICAL TO><ALPHA>." is encoded as A+ImIDkQ-. see RFC 1642
Assert.AreEqual (0x41, UTF7Bytes [0], "UTF7 #1");
Assert.AreEqual (0x2B, UTF7Bytes [1], "UTF7 #2");
Assert.AreEqual (0x49, UTF7Bytes [2], "UTF7 #3");
Assert.AreEqual (0x6D, UTF7Bytes [3], "UTF7 #4");
Assert.AreEqual (0x49, UTF7Bytes [4], "UTF7 #5");
Assert.AreEqual (0x44, UTF7Bytes [5], "UTF7 #6");
Assert.AreEqual (0x6B, UTF7Bytes [6], "UTF7 #7");
Assert.AreEqual (0x51, UTF7Bytes [7], "UTF7 #8");
Assert.AreEqual (0x2D, UTF7Bytes [8], "UTF7 #9");
Assert.AreEqual (0x2E, UTF7Bytes [9], "UTF7 #10");
}
public void NegTest8()
{
Byte[] bytes;
Char[] chars = new Char[] {
'\u0023',
'\u0025',
'\u03a0',
'\u03a3' };
UTF7Encoding UTF7 = new UTF7Encoding();
int byteCount = UTF7.GetByteCount(chars, 1, 2);
bytes = new Byte[byteCount];
Assert.Throws<ArgumentOutOfRangeException>(() =>
{
int bytesEncodedCount = UTF7.GetBytes(chars, chars.Length, 2, bytes, 1);
});
}
