private GetBytes ( char chars, int charCount, byte bytes, int byteCount ) : int | ||
chars | char | |
charCount | int | |
bytes | byte | |
byteCount | int | |
return | 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); }); }