public static string GetSystemTimeString(int tmCid)
{
var tmcTime = new byte[80];
Native.TmcSystemTime(tmCid, ref tmcTime, IntPtr.Zero);
return(EncodingUtil.Win1251BytesToUtf8(tmcTime));
}
/// <summary>
/// Encrypts the string encoded plain text
/// </summary>
/// <param name="asymmetricEncryptionAlgorithm"></param>
/// <param name="hashAlgorithm"></param>
/// <param name="asymmetricEncryptionPadding"></param>
/// <param name="asymmetricKeyParameter"></param>
/// <param name="plainText"></param>
/// <returns>Base64 encrypted encryptedInput text</returns>
private string doEncrypt(AsymmetricEncryptionAlgorithm asymmetricEncryptionAlgorithm, HashAlgorithm hashAlgorithm, AsymmetricEncryptionPadding asymmetricEncryptionPadding, AsymmetricKeyParameter asymmetricKeyParameter, string plainText)
{
IAsymmetricBlockCipher asymEngine = getEngine(asymmetricEncryptionAlgorithm);
IDigest hash = getDigest(hashAlgorithm);
IAsymmetricBlockCipher cipher = getPadding(asymEngine, hash, asymmetricEncryptionPadding);
BufferedAsymmetricBlockCipher bufferedCipher = new BufferedAsymmetricBlockCipher(cipher);
if (this.error.existsError())
{
return("");
}
bufferedCipher.Init(true, asymmetricKeyParameter);
EncodingUtil eu = new EncodingUtil();
byte[] inputBytes = eu.getBytes(plainText);
if (eu.GetError().existsError())
{
this.error = eu.GetError();
return("");
}
bufferedCipher.ProcessBytes(inputBytes, 0, inputBytes.Length);
byte[] outputBytes = bufferedCipher.DoFinal();
if (outputBytes == null || outputBytes.Length == 0)
{
this.error.setError("AE041", "Asymmetric encryption error");
return("");
}
this.error.cleanError();
return(Base64.ToBase64String(outputBytes));
}
public IEnumerable <Label> GetLabels(Topic topic, ImageLabel imageLabel)
{
#region validation
if (topic == null)
{
throw new ArgumentNullException(nameof(topic));
}
if (imageLabel == null)
{
throw new ArgumentNullException(nameof(imageLabel));
}
#endregion
IEnumerable <Label> labels = FileSession.Execute((fileName, filePath) =>
{
if (!FileContainer.ExistsFile(fileName, filePath))
{
return(new List <Label>());
}
using (StreamReader streamReader = EncodingUtil.GetStreamReader(FileContainer.GetFileStream(fileName, filePath), Encoding.UTF8))
{
string labelContentJson = streamReader.ReadToEnd();
return(JsonConvert.DeserializeObject <IEnumerable <Label> >(labelContentJson));
}
}, GetLabelFileName(imageLabel.Url), GetLabelsPath(topic));
imageLabel.SetLabels(labels);
return(labels);
}
/// <summary>
/// Read the stream from the cvs server.
/// </summary>
/// <param name="array">A byte array that is being read from the server.</param>
/// <returns>The integer value of the byte array.</returns>
public int Read(byte[] array)
{
int val = baseStream.Read(array, 0, array.Length);
ResponseMessage.SendMessage(EncodingUtil.GetString(array, 0, array.Length));
return(val);
}
private static void SaveFile(XtraTabControl pagesTabControl, CloudStorage cloudStorage, ICloudDirectoryEntry dir, String fileName, String content)
{
Stream data = null;
Encoding fileEncoding = EncodingUtil.GetDefaultEncoding();
if (pagesTabControl != null)
{
fileEncoding = TabUtil.GetTabTextEncoding(pagesTabControl.SelectedTabPage);
}
byte[] contentBytes = fileEncoding.GetBytes(content); //Convert actual encoding to UTF8 (Dropbox standard)
if (fileEncoding != Encoding.UTF8)
{
contentBytes = Encoding.Convert(fileEncoding, Encoding.UTF8, fileEncoding.GetBytes(content));
}
try
{
data = new MemoryStream(contentBytes);
cloudStorage.UploadFile(data, fileName, dir);
}
finally
{
if (data != null)
{
data.Close();
}
}
}
private async Task UpdateDeltaComponentPortStats(DeltaComponent component)
{
const int bufLength = 1024;
var buf = new byte[bufLength];
var result = await Task.Run(() =>
_native.TmcDntGetPortStats(_cid,
component.TraceChain,
ref buf,
bufLength))
.ConfigureAwait(false);
var portStatsString = EncodingUtil.Win1251BytesToUtf8(buf);
if (result == 0 || portStatsString.IsNullOrEmpty())
{
return;
}
var(ticks, statusCount, analogCount, accumCount, messagesCount) = ParsePortStatsString(portStatsString);
if (component.InitialPerformanceStats == null)
{
component.SetInitialPerformanceStats(ticks, statusCount, analogCount, accumCount, messagesCount);
return;
}
component.UpdatePerformanceStatsAndString(ticks, statusCount, analogCount, accumCount, messagesCount);
}
public Encoding AutoDetectEncoding(string fileName)
{
this.ValidateAndThrow();
Encoding encoding = Encoding.Default;
try
{
if (!string.IsNullOrEmpty(fileName))
{
using (Stream reader = File.OpenRead(fileName))
{
encoding = EncodingUtil.DetectEncoding(reader);
}
}
else if (this.DataStream != null)
{
encoding = EncodingUtil.DetectEncoding(this.DataStream);
}
}
catch (Exception ex)
{
encoding = Encoding.Default;
}
return(encoding);
}
/// <summary>
/// Decrypts the base64 encoded encrypted text
/// </summary>
/// <param name="asymmetricEncryptionAlgorithm">string AsymmetricEncryptionAlgorithm enum, algorithm name</param>
/// <param name="hashAlgorithm">string HashAlgorithm enum, algorithm name</param>
/// <param name="asymmetricEncryptionPadding">string AsymmetricEncryptionPadding enum, padding name</param>
/// <param name="asymmetricKeyParameter">AsymmetricKeyParameter with loaded key for specified algorithm</param>
/// <param name="encryptedInput">string Base64 to decrypt</param>
/// <returns>string decypted encryptedInput text</returns>
private string doDecrypt(AsymmetricEncryptionAlgorithm asymmetricEncryptionAlgorithm, HashAlgorithm hashAlgorithm, AsymmetricEncryptionPadding asymmetricEncryptionPadding, AsymmetricKeyParameter asymmetricKeyParameter, string encryptedInput)
{
IAsymmetricBlockCipher asymEngine = getEngine(asymmetricEncryptionAlgorithm);
IDigest hash = getDigest(hashAlgorithm);
IAsymmetricBlockCipher cipher = getPadding(asymEngine, hash, asymmetricEncryptionPadding);
BufferedAsymmetricBlockCipher bufferedCipher = new BufferedAsymmetricBlockCipher(cipher);
if (this.error.existsError())
{
return("");
}
bufferedCipher.Init(false, asymmetricKeyParameter);
byte[] inputBytes = Base64.Decode(encryptedInput);
bufferedCipher.ProcessBytes(inputBytes, 0, inputBytes.Length);
byte[] outputBytes = bufferedCipher.DoFinal();
if (outputBytes == null || outputBytes.Length == 0)
{
this.error.setError("AE040", "Asymmetric decryption error");
return("");
}
EncodingUtil eu = new EncodingUtil();
this.error = eu.GetError();
return(eu.getString(outputBytes));
}
public static TmServer CreateFromIfaceServer(TmNativeDefs.IfaceServer ifaceServer)
{
var name = EncodingUtil.Win1251BytesToUtf8(ifaceServer.Name);
var comment = EncodingUtil.Win1251BytesToUtf8(ifaceServer.Comment);
var tmServer = new TmServer((name, comment, ifaceServer.Signature, ifaceServer.Unique).ToTuple().GetHashCode())
{
Name = name,
Comment = comment,
Signature = ifaceServer.Signature,
Unique = ifaceServer.Unique,
ProcessId = ifaceServer.Pid,
ParentProcessId = ifaceServer.Ppid,
Flags = ifaceServer.Flags,
DbgCnt = ifaceServer.DbgCnt,
LoudCnt = ifaceServer.LoudCnt,
BytesIn = ifaceServer.BytesIn,
BytesOut = ifaceServer.BytesOut,
State = ifaceServer.State,
CreationTime = DateUtil.GetDateTimeFromTimestamp(ifaceServer.CreationTime),
ResState = ifaceServer.ResState
};
return(tmServer);
}
/// <summary>
/// Decompresses data into the byte array
/// </summary>
/// <param name ="array">
/// the array to read and decompress data into
/// </param>
/// <param name ="offset">
/// the offset indicating where the data should be placed
/// </param>
/// <param name ="length">
/// the number of bytes to decompress
/// </param>
public override int Read(byte[] array, int offset, int length)
{
int val = baseStream.Read(array, offset, length);
ResponseMessage.SendMessage(EncodingUtil.GetString(array, offset, length));
return(val);
}
public virtual void SetUp()
{
plainText = "Neque porro quisquam est qui dolorem ipsum quia dolor sit amet";
plainTextCTS = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aliquam venenatis ex sit amet risus pellentesque, a faucibus quam ultrices. Ut tincidunt quam eu aliquam maximus. Quisque posuere risus at erat blandit eleifend. Curabitur viverra rutrum volutpat. Donec quis quam tellus. Aenean fermentum elementum augue, a semper risus scelerisque sit amet. Nullam vitae sapien vitae dui ullamcorper dapibus quis quis leo. Sed neque felis, pellentesque in risus et, lobortis ultricies nulla. Quisque quis quam risus. Donec vestibulum, lectus vel vestibulum eleifend, velit ante volutpat lacus, ut mattis quam ligula eget est. Sed et pulvinar lectus. In mollis turpis non ipsum vehicula, sit amet rutrum nibh dictum. Duis consectetur convallis ex, eu ultricies enim bibendum vel. Vestibulum vel libero nibh. Morbi nec odio mattis, vestibulum quam blandit, pretium orci.Aenean pellentesque tincidunt nunc a malesuada. Etiam gravida fermentum mi, at dignissim dui aliquam quis. Nullam vel lobortis libero. Phasellus non gravida posuere";
keyGen = new SymmetricKeyGenerator();
/**** CREATE KEYS ****/
key1024 = keyGen.doGenerateKey("GENERICRANDOM", 1024);
key512 = keyGen.doGenerateKey("GENERICRANDOM", 512);
key448 = keyGen.doGenerateKey("GENERICRANDOM", 448);
key256 = keyGen.doGenerateKey("GENERICRANDOM", 256);
key160 = keyGen.doGenerateKey("GENERICRANDOM", 160);
key192 = keyGen.doGenerateKey("GENERICRANDOM", 192);
key128 = keyGen.doGenerateKey("GENERICRANDOM", 128);
key64 = keyGen.doGenerateKey("GENERICRANDOM", 64);
/**** CREATE IVs ****/
IV128 = keyGen.doGenerateIV("GENERICRANDOM", 128);
IV64 = keyGen.doGenerateIV("GENERICRANDOM", 64);
encodings = new string[] { "UTF_8", "UTF_16", "UTF_16BE", "UTF_16LE", "UTF_32", "UTF_32BE", "UTF_32LE", "SJIS", "GB2312" };
eu = new EncodingUtil();
}
// ---------------------------------------
// ------ Value Extraction ---------------
// ---------------------------------------
public Blob getBlobValue()
{
if (value is string)
{
return(EncodingUtil.base64Decode((string)value));
}
throw new InvalidConversionException("Only String values can be converted to a Blob: " + toStringPretty());
}
/// <summary>
/// Decrypts the given encrypted text with an AEAD encryption algorithm
/// </summary>
/// <param name="symmetricBlockAlgorithm">string SymmetricBlockAlgorithm enum, symmetric block algorithm name</param>
/// <param name="symmetricBlockMode">string SymmetricBlockModes enum, symmetric block mode name</param>
/// <param name="key">string Hexa key for the algorithm excecution</param>
/// <param name="macSize">int macSize in bits for MAC length for AEAD Encryption algorithm</param>
/// <param name="nonce">string Hexa nonce for MAC length for AEAD Encryption algorithm</param>
/// <param name="encryptedInput">string Base64 text to decrypt</param>
/// <returns></returns>
public string DoAEADDecrypt(string symmetricBlockAlgorithm, string symmetricBlockMode,
string key, int macSize, string nonce, string encryptedInput)
{
this.error.cleanError();
SymmetricBlockAlgorithm algorithm = SymmetricBlockAlgorithmUtils.getSymmetricBlockAlgorithm(symmetricBlockAlgorithm, this.error);
SymmetricBlockMode mode = SymmetricBlockModeUtils.getSymmetricBlockMode(symmetricBlockMode, this.error);
if (this.error.existsError())
{
return("");
}
IBlockCipher engine = getCipherEngine(algorithm);
IAeadBlockCipher bbc = getAEADCipherMode(engine, mode);
if (this.error.existsError() && !(string.Compare(this.error.Code, "SB016", true) == 0))
{
return("");
}
byte[] nonceBytes = SecurityUtils.GetHexa(nonce, "SB025", this.error);
byte[] keyBytes = SecurityUtils.GetHexa(key, "SB025", this.error);
if (this.HasError())
{
return("");
}
KeyParameter keyParam = new KeyParameter(keyBytes);
AeadParameters AEADparams = new AeadParameters(keyParam, macSize, nonceBytes);
try
{
bbc.Init(false, AEADparams);
}catch (Exception e)
{
this.error.setError("SB030", e.Message);
return("");
}
byte[] out2 = Base64.Decode(encryptedInput);
byte[] comparisonBytes = new byte[bbc.GetOutputSize(out2.Length)];
int length = bbc.ProcessBytes(out2, 0, out2.Length, comparisonBytes, 0);
try
{
bbc.DoFinal(comparisonBytes, length);
}
catch (Exception)
{
this.error.setError("SB012", "AEAD decryption exception");
return("");
}
this.error.cleanError();
// return System.Text.Encoding.UTF8.GetString(comparisonBytes).Trim();
EncodingUtil eu = new EncodingUtil();
this.error = eu.GetError();
return(eu.getString(comparisonBytes));
}
public JWTCreator() : base()
{
EncodingUtil eu = new EncodingUtil();
eu.setEncoding("UTF8");
this.counter = 0;
/***Config to Debug - Delete on Release version!!!***/
Microsoft.IdentityModel.Logging.IdentityModelEventSource.ShowPII = true;
}
/**
* Detects encoding from a stream.
*
* @param inp the stream
* @return a Reader with the deduced encoding.
* @throws IOException if IO went wrong
* @throws UnsupportedEncodingException if unsupported encoding was detected
*/
virtual public StreamReader DetectEncoding(Stream inp)
{
byte[] b4 = new byte[4];
int count = inp.Read(b4, 0, b4.Length);
if (count != 4)
{
throw new IOException("Insufficient length");
}
String encoding = XMLUtil.GetEncodingName(b4);
String decl = null;
int bytesNumber = 0;
if (encoding.Equals("UTF-8"))
{
StringBuilder sb = new StringBuilder();
int c;
while (bytesNumber < 1028 && ((c = inp.ReadByte()) != -1))
{
if (c == '>')
{
break;
}
sb.Append((char)c);
bytesNumber++;
}
decl = sb.ToString();
}
else if (encoding.Equals("CP037"))
{
MemoryStream bi = new MemoryStream();
int c;
while (bytesNumber < 1028 && ((c = inp.ReadByte()) != -1))
{
if (c == 0x6e) // that's '>' in ebcdic
{
break;
}
bi.WriteByte((byte)c);
bytesNumber++;
}
decl = Encoding.GetEncoding(37).GetString(bi.ToArray());
}
if (decl != null)
{
decl = EncodingUtil.GetDeclaredEncoding(decl);
if (decl != null)
{
encoding = decl;
}
}
if (inp.CanSeek)
{
inp.Seek(0, SeekOrigin.Begin);
}
return(new StreamReader(inp, IanaEncodings.GetEncodingEncoding(encoding)));
}
public virtual string GetXmlPart()
{
if (Value != null)
{
return(String.Format("<{0}>{1}</{0}>", SoapElementName, EncodingUtil.XmlEncode(Value)));
}
return(null);
}
public virtual void TestCreatesValidProlog()
{
Document document = Document.CreateShell("");
document.OutputSettings().Syntax(Syntax.xml);
document.Charset(EncodingUtil.GetEncoding("utf-8"));
NUnit.Framework.Assert.AreEqual("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + "<html>\n" + " <head></head>\n"
+ " <body></body>\n" + "</html>", document.OuterHtml());
}
public virtual void TestMetaCharsetUpdateEnabledAfterCharsetChange()
{
Document doc = CreateHtmlDocument("dontTouch");
doc.Charset(EncodingUtil.GetEncoding(charsetUtf8));
iText.StyledXmlParser.Jsoup.Nodes.Element selectedElement = doc.Select("meta[charset]").First();
NUnit.Framework.Assert.AreEqual(charsetUtf8, selectedElement.Attr("charset"));
NUnit.Framework.Assert.IsTrue(doc.Select("meta[name=charset]").IsEmpty());
}
public static bool CharsetIsSupported(string charset)
{
try {
var enc = EncodingUtil.GetEncoding(charset);
return(true);
} catch (ArgumentException) {
return(false);
}
}
public virtual void DiscardsSpuriousByteOrderMark()
{
String html = "\uFEFF<html><head><title>One</title></head><body>Two</body></html>";
ByteBuffer buffer = EncodingUtil.GetEncoding("UTF-8").Encode(html);
Document doc = DataUtil.ParseByteData(buffer, "UTF-8", "http://foo.com/", iText.StyledXmlParser.Jsoup.Parser.Parser
.HtmlParser());
NUnit.Framework.Assert.AreEqual("One", doc.Head().Text());
}
protected override IEnumerable <CommandParameters> Execute(IEnumerable <CommandParameters> inParametersList)
{
foreach (var inParameters in inParametersList)
{
//inParameters = GetCurrentInParameters();
string file = inParameters.GetValue <string>("File");
string encodingName = inParameters.GetValue <string>("EncodingName");
string tableName = inParameters.GetValue <string>("TableName");
string columnPrefix = inParameters.GetValue <string>("ColumnPrefix");
if (string.IsNullOrEmpty(encodingName))
{
this.AutoDetectSettings();
encodingName = this.EncodingName;
}
this.LogDebugFormat("Start reading File='{0}'", file);
this.fileAdapter.FileName = file;
this.fileAdapter.Encoding = EncodingUtil.GetEncodingOrDefault(encodingName);
var formatter = new FlatFileToDataTableFormatter();
formatter.ColumnName = columnPrefix + "_ROW";
this.fileAdapter.ReadFormatter = formatter;
int rowCount = 0;
foreach (var table in this.fileAdapter.ReadData(this.MaxRowsToRead))
{
table.TableName = tableName;
table.Columns.AddWhenNotExist(columnPrefix + "_ID", typeof(long));
table.Columns.AddWhenNotExist(columnPrefix + "_FILE_NAME", typeof(string));
table.Columns.AddWhenNotExist(columnPrefix + "_STATUS", typeof(string));
table.Columns.AddWhenNotExist(columnPrefix + "_TRANSFARE_DATE", typeof(DateTime));
table.Columns.AddWhenNotExist(columnPrefix + "_INSERT_DATE", typeof(DateTime));
table.Columns.AddWhenNotExist(columnPrefix + "_INSERT_USER", typeof(string));
table.Columns.AddWhenNotExist(columnPrefix + "_UPDATE_DATE", typeof(DateTime));
table.Columns.AddWhenNotExist(columnPrefix + "_UPDATE_USER", typeof(string));
foreach (DataRow row in table.Rows)
{
row[columnPrefix + "_FILE_NAME"] = this.fileAdapter.FileName;
row[columnPrefix + "_STATUS"] = "pending";
}
rowCount += table.Rows.Count;
var outParameters = this.GetCurrentOutParameters();
outParameters.SetOrAddValue("Data", table);
outParameters.SetOrAddValue("DataName", table.TableName);
yield return(outParameters);
}
this.LogDebugFormat("End reading File='{0}': Rows={1}", file, rowCount);
}
}
static string DetectSingerPath(string path, Encoding ustEncoding)
{
var pathEncoding = DetectSingerPathEncoding(path, ustEncoding);
if (pathEncoding == null)
{
return("");
}
return(PathManager.Inst.GetSingerAbsPath(EncodingUtil.ConvertEncoding(ustEncoding, pathEncoding, path)));
}
public void Test_EncodingUtil_DetermineEncoding_ShouldReturnCorrectEncoding(Stream stream, string expectedEncoding)
{
var sut = new EncodingUtil();
var result = sut.DetermineEncoding(stream);
result.Should().NotBeNull();
var encoding = result.EncodingName;
encoding.Should().Be(expectedEncoding);
}
/// <summary>
/// Converts a
/// <c>byte</c>
/// array to a
/// <c>String</c>
/// according
/// to the some encoding.
/// </summary>
/// <param name="bytes">the bytes to convert</param>
/// <param name="encoding">the encoding</param>
/// <returns>
/// the converted
/// <c>String</c>
/// </returns>
public static String ConvertToString(byte[] bytes, String encoding)
{
if (bytes == null)
{
return(EMPTY_STRING);
}
if (encoding == null || encoding.Length == 0)
{
char[] c = new char[bytes.Length];
for (int k = 0; k < bytes.Length; ++k)
{
c[k] = (char)(bytes[k] & 0xff);
}
return(new String(c));
}
IExtraEncoding extra = extraEncodings.Get(encoding.ToLower(System.Globalization.CultureInfo.InvariantCulture
));
if (extra != null)
{
String text = extra.ByteToChar(bytes, encoding);
if (text != null)
{
return(text);
}
}
char[] ch = null;
if (encoding.Equals(WINANSI))
{
ch = winansiByteToChar;
}
else
{
if (encoding.Equals(PDF_DOC_ENCODING))
{
ch = pdfEncodingByteToChar;
}
}
if (ch != null)
{
int len = bytes.Length;
char[] c = new char[len];
for (int k = 0; k < len; ++k)
{
c[k] = ch[bytes[k] & 0xff];
}
return(new String(c));
}
try {
return(EncodingUtil.ConvertToString(bytes, encoding));
}
catch (ArgumentException e) {
throw new iText.IO.IOException(iText.IO.IOException.PdfEncodings, e);
}
}
public virtual void TestMetaCharsetUpdateCleanup()
{
Document doc = CreateHtmlDocument("dontTouch");
doc.UpdateMetaCharsetElement(true);
doc.Charset(EncodingUtil.GetEncoding(charsetUtf8));
String htmlCharsetUTF8 = "<html>\n" + " <head>\n" + " <meta charset=\"" + charsetUtf8 + "\">\n" + " </head>\n"
+ " <body></body>\n" + "</html>";
NUnit.Framework.Assert.AreEqual(htmlCharsetUTF8, doc.ToString());
}
public void GetEncodingTest()
{
const CodePage cp0 = CodePage.Utf8;
Encoding e = Encoding.UTF8;
Assert.Equal(e, EncodingUtil.GetEncoding(cp0));
const string data0 = "Hello, world!";
Assert.Equal(e.GetBytes(data0), EncodingUtil.GetEncodedBytes(data0, cp0));
}
/// <summary>
/// Save list of objectclasses in json-file.
/// </summary>
/// <param name="topic">Topic of objectclasses</param>
/// <param name="objectClasses">List of objectclasses to save</param>
private void SaveObjectClasses(Topic topic, IEnumerable <ObjectClass> objectClasses)
{
FileSession.Execute((fileName, filePath) =>
{
string objectclassesAsJson = JsonSerializer.Serialize(objectClasses);
byte[] newFileContent = EncodingUtil.GetBytes(objectclassesAsJson);
FileContainer.CreateFile(fileName, newFileContent, filePath);
return(true);
}, "objectclasses.json", GetTopicPath(topic));
}
public static bool CanEncode(this Encoding encoding, byte[] src)
{
try {
byte[] dest = Encoding.Convert(Encoding.Unicode,
EncodingUtil.GetEncoding(encoding.CodePage, new EncoderExceptionFallback(),
new DecoderExceptionFallback()), src);
} catch (EncoderFallbackException) {
return(false);
}
return(true);
}
private static string GetDeltaItemAdditionalText(IntPtr itemPtr, int itemStructLength, int actualLength)
{
if (actualLength <= itemStructLength + 1)
{
return("");
}
var result = Marshal.PtrToStringAnsi(IntPtr.Add(itemPtr, itemStructLength + 1));
return(EncodingUtil.Win1251ToUtf8(result));
}
public virtual void TestMetaCharsetUpdateNoCharset()
{
Document docNoCharset = Document.CreateShell("");
docNoCharset.UpdateMetaCharsetElement(true);
docNoCharset.Charset(EncodingUtil.GetEncoding(charsetUtf8));
NUnit.Framework.Assert.AreEqual(charsetUtf8, docNoCharset.Select("meta[charset]").First().Attr("charset"));
String htmlCharsetUTF8 = "<html>\n" + " <head>\n" + " <meta charset=\"" + charsetUtf8 + "\">\n" + " </head>\n"
+ " <body></body>\n" + "</html>";
NUnit.Framework.Assert.AreEqual(htmlCharsetUTF8, docNoCharset.ToString());
}
