/// <summary>
/// Deserializing constructor.
/// </summary>
public TbxUser(SerializationInfo info, StreamingContext context)
{
Int32 version = Misc.GetSerializationVersion(info);
UserID = info.GetUInt32("UserID");
Misc.TryGetUInt64(info, ref InvitationDate, "InvitationDate", 0);
Misc.TryGetUInt32(info, ref InvitedBy, "InvitedBy", 0);
AdminName = info.GetString("AdminName");
UserName = info.GetString("UserName");
EmailAddress = info.GetString("EmailAddress");
OrgName = info.GetString("OrgName");
if (version < 7)
{
if (info.GetUInt32("Power") > 0)
{
AdminFlag = true;
ManagerFlag = true;
}
if (UserName != "")
{
RegisterFlag = true;
}
}
if (version >= 7)
{
Flags = info.GetUInt32("Flags");
}
}
public StarMapFeature(SerializationInfo info, StreamingContext context)
{
//m_Stride = info.GetInt32("m_Stride");
//m_BytesPerPixel = info.GetInt32("m_BytesPerPixel");
m_MaxBrightness = info.GetByte("m_MaxBrightness");
m_MaxBrightnessFirstKey = info.GetUInt64("m_MaxBrightnessFirstKey");
m_MaxBrightnessPixels = info.GetInt32("m_MaxBrightnessPixels");
m_Generation = info.GetInt32("m_Generation");
m_Merges = info.GetInt32("m_Merges");
m_FeatureId = info.GetInt32("FeatureId");
m_Intencity = info.GetUInt32("m_Intencity");
int count = info.GetInt32("m_Pixels.Count");
int idx = -1;
m_Pixels = new SortedDictionary <ulong, uint>();
for (int i = 0; i < count; i++)
{
idx++;
ulong key = info.GetUInt64(string.Format("m_Pixels.{0}.Key", idx));
uint val = info.GetUInt32(string.Format("m_Pixels.{0}.Value", idx));
m_Pixels.Add(key, val);
}
}
public Block(SerializationInfo info, StreamingContext context)
{
// built-in value
_bits = info.GetUInt32("built-int");
// cutom bits
_customBits = new uint[info.GetUInt16("cBitCount")];
int length = _customBits.Length;
for (int i = 0; i < length; i++)
{
_customBits[i] = info.GetUInt32("cBit" + i);
}
// custom floats
length = info.GetUInt16("cFloatCount");
_customFloats = new ConcurrentDictionary <int, float>(3, length * 2);
for (int i = 0; i < length; i++)
{
_customFloats[info.GetInt32("cFloatKey" + i)] = info.GetSingle("cFloatValue" + i);
}
// custom strings
length = info.GetUInt16("cStringCount");
_customStrings = new ConcurrentDictionary <int, string>(3, length * 2);
for (int i = 0; i < length; i++)
{
_customStrings[info.GetInt32("cStringKey" + i)] = info.GetString("cStringValue" + i);
}
}
/// <summary>
/// Creates a new <see cref="CommonFrameHeader"/> from serialization parameters.
/// </summary>
/// <param name="info">The <see cref="SerializationInfo"/> with populated with data.</param>
/// <param name="context">The source <see cref="StreamingContext"/> for this deserialization.</param>
protected CommonFrameHeader(SerializationInfo info, StreamingContext context)
{
// Deserialize common frame header
m_frameType = (FrameType)info.GetValue("frameType", typeof(FrameType));
m_version = info.GetByte("version");
m_frameLength = info.GetUInt16("frameLength");
m_timebase = info.GetUInt32("timebase");
m_timeQualityFlags = info.GetUInt32("timeQualityFlags");
if (m_frameType != IEC61850_90_5.FrameType.DataFrame)
{
return;
}
m_headerLength = info.GetUInt16("headerLength");
m_dataLength = info.GetUInt16("dataLength");
m_packetNumber = info.GetUInt32("packetNumber");
m_signatureAlgorithm = (SignatureAlgorithm)info.GetValue("signatureAlgorithm", typeof(SignatureAlgorithm));
m_securityAlgorithm = (SecurityAlgorithm)info.GetValue("securityAlgorithm", typeof(SecurityAlgorithm));
m_asduCount = info.GetInt32("adsuCount");
m_simulatedData = info.GetBoolean("simulatedData");
m_applicationID = info.GetUInt16("applicationID");
m_payloadSize = info.GetUInt16("payloadSize");
m_keyID = info.GetUInt32("keyID");
}
/// <summary>
/// Initializes a new instance of the <see cref="VersionNotSupportedException"/> class (used during deserialization).
/// </summary>
/// <param name="info">The <see cref="SerializationInfo"/> that receives the serialized object data about the object.</param>
/// <param name="context">The <see cref="StreamingContext"/> that contains contextual information about the source or destination.</param>
protected VersionNotSupportedException(SerializationInfo info, StreamingContext context) :
base(info, context)
{
Type = (Type)info.GetValue("Type", typeof(Type));
RequestedVersion = info.GetUInt32("RequestedVersion");
MaxVersion = info.GetUInt32("MaxVersion");
}
protected ConfigBattle(SerializationInfo info, StreamingContext context)
{
//read
bid = info.GetUInt32("bid");
level = info.GetUInt32("level");
name = info.GetString("name");
desc = info.GetString("desc");
}
protected QuestBase(SerializationInfo info, StreamingContext context)
{
index = info.GetUInt32("index");
isnew = info.GetBoolean("isnew");
IsWaypointsCleared = info.GetBoolean("cleared");
QuestId = info.GetUInt32("questid");
questtype = info.GetByte("questtype");
}
protected ConfigModule(SerializationInfo info, StreamingContext context)
{
//read
bid = info.GetUInt32("bid");
name = info.GetString("name");
module = info.GetString("module");
level = info.GetUInt32("level");
}
protected ConfigItem(SerializationInfo info, StreamingContext context)
{
//read
bid = info.GetUInt32("bid");
name = info.GetString("name");
quality = info.GetUInt32("quality");
icon = info.GetUInt32("icon");
desc = info.GetString("desc");
}
// The special constructor is used to deserialize values.
private LSystemState(SerializationInfo info, StreamingContext context)
{
currentSymbols = info.GetValue <DependencyTracker <SymbolString <T> > >("currentSymbols");
randomProvider = new Unity.Mathematics.Random(info.GetUInt32("randomSeed"));
firstUniqueOrganId = info.GetUInt32("firstUniqueOrganId");
maxUniqueOrganIds = info.GetUInt32("maxUniqueOrganIds");
hasImmatureSymbols = info.GetBoolean("hasImmatureSymbols");
}
/// <summary>
/// Initializes a new instance of the <see cref="Texture2D"/> class.
/// </summary>
/// <param name="info">The info.</param>
/// <param name="context">The context.</param>
private TypelessTexture2D(SerializationInfo info, StreamingContext context)
: base(info, context)
{
this.format = info.GetValue("Format", typeof(PixelFormat)) as PixelFormat;
this.width = info.GetUInt32("Width");
this.height = info.GetUInt32("Height");
this.mipmapCount = info.GetUInt32("MipmapCount");
this.swData = info.GetValue("Data", typeof(byte[][])) as byte[][];
}
/// <summary>
/// Creates a new <see cref="CommonFrameHeader"/> from serialization parameters.
/// </summary>
/// <param name="info">The <see cref="SerializationInfo"/> with populated with data.</param>
/// <param name="context">The source <see cref="StreamingContext"/> for this deserialization.</param>
protected CommonFrameHeader(SerializationInfo info, StreamingContext context)
{
// Deserialize common frame header
m_frameType = (FrameType)info.GetValue("frameType", typeof(FrameType));
m_version = info.GetByte("version");
m_frameLength = info.GetUInt16("frameLength");
m_timebase = info.GetUInt32("timebase");
m_timeQualityFlags = info.GetUInt32("timeQualityFlags");
}
/// <summary>
/// The serialization constructor. This function is normally not called directly by user code.
/// </summary>
/// <param name="info">The SerializationInfo object from the serializer.</param>
/// <param name="context">This parameter is ignored.</param>
public LuaBlock([NotNull] SerializationInfo info, StreamingContext context)
{
ID = info.GetUInt32("id");
Stamp = DateTimeOffset.FromUnixTimeSeconds(info.GetInt64("stamp"));
Type = (CommandType)info.GetByte("type");
Message = info.GetString("message") ?? string.Empty;
Address = info.GetUInt32("address");
Domain = info.GetString("domain") ?? string.Empty;
Value = info.GetUInt32("value");
Block = info.GetValue("block", typeof(byte[])) as byte[];
}
/// <summary>
/// Deserialization constructor
/// </summary>
/// <param name="info">Serialization info</param>
/// <param name="context">Streaming context</param>
protected LogHolder(SerializationInfo info, StreamingContext context)
{
try
{
begin = info.GetUInt32("Begin");
end = info.GetUInt32("End");
}
catch
{
}
Url = info.GetString("Url");
}
/// <summary>
/// Deserializes the service result.
/// </summary>
/// <param name="info">The info.</param>
/// <param name="prefix">The prefix.</param>
/// <returns></returns>
private static ServiceResult DeserializeServiceResult(SerializationInfo info, string prefix)
{
uint statusCode = info.GetUInt32(prefix + "StatusCode");
string namespaceUri = info.GetString(prefix + "NamespaceUri");
string symbolicId = info.GetString(prefix + "SymbolicId");
string additionalInfo = info.GetString(prefix + "AdditionalInfo");
bool isLocalizedTextNull = false;
string localizedTextText = null;
LocalizedText localizedText = null;
try
{
localizedTextText = info.GetString(prefix + "LocalizedTextText");
}
catch (SerializationException ex)
{
isLocalizedTextNull = true;
Utils.Trace("Deserialization - localized text is null." + ex.Message);
}
if (!isLocalizedTextNull)
{
string localizedTextKey = info.GetString(prefix + "LocalizedTextKey");
string localizedTextLocale = info.GetString(prefix + "LocalizedTextLocale");
if (localizedTextText != null || localizedTextLocale != null || localizedTextKey != null)
{
localizedText = new LocalizedText(localizedTextKey, localizedTextLocale, localizedTextText);
}
}
bool isInnerResultNull = false;
ServiceResult innerServiceResult = null;
uint innerResultStatusCode;
try
{
innerResultStatusCode = info.GetUInt32(prefix + "InnerResultStatusCode");
}
catch (SerializationException ex)
{
isInnerResultNull = true;
Utils.Trace("Deserialization - inner result is null." + ex.Message);
}
if (!isInnerResultNull)
{
innerServiceResult = DeserializeServiceResult(info, prefix + "InnerResult");
}
return(new ServiceResult(statusCode, symbolicId, namespaceUri, localizedText, additionalInfo, innerServiceResult));
}
public LibraryEntry(SerializationInfo info, StreamingContext context)
{
this.FileName = info.GetString("FileName");
this.Album = info.GetString("Album");
this.Title = info.GetString("Title");
this.Year = info.GetUInt32("Year");
this.Track = info.GetUInt32("Track");
this.Disc = info.GetUInt32("Disc");
this.DiscCount = info.GetUInt32("DiscCount");
this.AlbumArtists = (SortedObservableCollection <string, string>)info.GetValue("AlbumArtists", typeof(SortedObservableCollection <string, string>));
this.Genres = (SortedObservableCollection <string, string>)info.GetValue("Genres", typeof(SortedObservableCollection <string, string>));
}
//This function is necessary for soap Deserialization
protected CDNMessage(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
throw new System.ArgumentNullException("info");
}
this.id = (MSGID)info.GetUInt32("id");
this.content = info.GetString("content");
this.from = (CDNNetWork.CNDTYPE)info.GetUInt32("from");
this.to = (CDNNetWork.CNDTYPE)info.GetUInt32("to");
this.client = info.GetValue("client", typeof(AddressAndPort)) as AddressAndPort;
this.cache = info.GetValue("cache", typeof(AddressAndPort)) as AddressAndPort;
this.server = info.GetValue("server", typeof(AddressAndPort)) as AddressAndPort;
}
public Coords(SerializationInfo info, StreamingContext context)
{
this._sectorIndexX = info.GetUInt32("sectorIndexX");
this._sectorIndexY = info.GetUInt32("sectorIndexY");
int sX, sY, sZ;
sX = info.GetInt32("sX");
sY = info.GetInt32("sY");
sZ = info.GetInt32("sZ");
this._sectorLocation = new SectorLocation(sX, sY, sZ);
this._galacticLocation = new GalacticLocation(_sectorIndexX, _sectorIndexY, _sectorLocation);
this._screenLocation = new ScreenLocation(_sectorLocation);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActiveScriptException"/> class with serialized data
/// </summary>
/// <param name="info">The object that holds the serialized data</param>
/// <param name="context">The contextual information about the source or destination</param>
private ActiveScriptException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
if (info != null)
{
_errorCode = info.GetInt32("ErrorCode");
_errorWCode = info.GetInt16("ErrorWCode");
_sourceContext = info.GetUInt32("SourceContext");
_subcategory = info.GetString("Subcategory");
_lineNumber = info.GetUInt32("LineNumber");
_columnNumber = info.GetInt32("ColumnNumber");
_sourceError = info.GetString("SourceError");
}
}
/// <summary>
/// Creates a new <see cref="FrequencyDefinitionBase"/> from serialization parameters.
/// </summary>
/// <param name="info">The <see cref="SerializationInfo"/> with populated with data.</param>
/// <param name="context">The source <see cref="StreamingContext"/> for this deserialization.</param>
protected FrequencyDefinitionBase(SerializationInfo info, StreamingContext context)
: base(info, context)
{
// Deserialize frequency definition
m_dfdtScale = info.GetUInt32("dfdtScale");
m_dfdtOffset = info.GetDouble("dfdtOffset");
}
/// <summary>
/// Creates a new <see cref="CommonFrameHeader"/> from serialization parameters.
/// </summary>
/// <param name="info">The <see cref="SerializationInfo"/> with populated with data.</param>
/// <param name="context">The source <see cref="StreamingContext"/> for this deserialization.</param>
protected CommonFrameHeader(SerializationInfo info, StreamingContext context)
{
// Deserialize common frame header
m_packetNumber = info.GetByte("packetNumber");
m_wordCount = info.GetUInt16("wordCount");
// The usePhasorDataFileFormat flag and other new elements did not exist in prior versions so we protect against possible deserialization failures
try
{
m_usePhasorDataFileFormat = info.GetBoolean("usePhasorDataFileFormat");
RoughTimestamp = info.GetInt64("roughTimestamp");
m_fileType = (FileType)info.GetValue("fileType", typeof(FileType));
m_fileVersion = (FileVersion)info.GetValue("fileVersion", typeof(FileVersion));
m_sourceID = info.GetString("sourceID");
m_startSample = info.GetUInt32("startSample");
}
catch (SerializationException)
{
m_usePhasorDataFileFormat = false;
RoughTimestamp = 0;
m_fileType = FileType.PdcUnix;
m_fileVersion = FileVersion.PdcWithoutDbuf;
m_sourceID = "UNDF";
m_startSample = 0;
}
}
/// <summary>
/// Creates a new <see cref="ConfigurationFrame1"/> from serialization parameters.
/// </summary>
/// <param name="info">The <see cref="SerializationInfo"/> with populated with data.</param>
/// <param name="context">The source <see cref="StreamingContext"/> for this deserialization.</param>
protected ConfigurationFrame1(SerializationInfo info, StreamingContext context)
: base(info, context)
{
// Deserialize configuration frame
m_frameHeader = (CommonFrameHeader)info.GetValue("frameHeader", typeof(CommonFrameHeader));
m_timebase = info.GetUInt32("timebase");
}
public void SerializationInfo_AddGet()
{
var value = new Serializable();
var si = new SerializationInfo(typeof(Serializable), new FormatterConverter());
var sc = new StreamingContext();
value.GetObjectData(si, sc);
Assert.AreEqual(typeof(Serializable), si.ObjectType);
Assert.AreEqual(typeof(Serializable).FullName, si.FullTypeName);
// TODO: Implement AssemblyName property
// Assert.AreEqual(typeof(Serializable).Assembly.FullName, si.AssemblyName);
Assert.AreEqual(15, si.MemberCount);
Assert.AreEqual(true, si.GetBoolean("bool"));
Assert.AreEqual("hello", si.GetString("string"));
Assert.AreEqual('a', si.GetChar("char"));
Assert.AreEqual(byte.MaxValue, si.GetByte("byte"));
Assert.AreEqual(decimal.MaxValue, si.GetDecimal("decimal"));
Assert.AreEqual(double.MaxValue, si.GetDouble("double"));
Assert.AreEqual(short.MaxValue, si.GetInt16("short"));
Assert.AreEqual(int.MaxValue, si.GetInt32("int"));
Assert.AreEqual(long.MaxValue, si.GetInt64("long"));
Assert.AreEqual(sbyte.MaxValue, si.GetSByte("sbyte"));
Assert.AreEqual(float.MaxValue, si.GetSingle("float"));
Assert.AreEqual(ushort.MaxValue, si.GetUInt16("ushort"));
Assert.AreEqual(uint.MaxValue, si.GetUInt32("uint"));
Assert.AreEqual(ulong.MaxValue, si.GetUInt64("ulong"));
Assert.AreEqual(DateTime.MaxValue, si.GetDateTime("datetime"));
}
} // end IsActivated
//-
#endregion
#region ISerializable
/// <summary>
/// Contructs a <b>ControlDaSubscription</b> object by de-serializing it from the stream.
/// </summary>
/// <include
/// file='TBNC.doc.xml'
/// path='//class[@name="ControlDaSubscription"]/method[@name="ControlDaSubscription"]/doc/*'
/// />
protected ControlDaSubscription(SerializationInfo info, StreamingContext context) :
base(info, context)
{
m_name = info.GetString("m_name");
m_updateRate = info.GetUInt32("m_updateRate");
m_isActivated = info.GetBoolean("m_isActivated");
}
/// <summary>
/// Constructor used to deserialise a <see cref="PropVariant"/> that has previously been serialised. The serialisation process uses the
/// <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/bb776579(v=vs.85).aspx">StgSerializePropVariant</a> and
/// <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/bb776578(v=vs.85).aspx">StgDeserializePropVariant</a> functions to perform
/// the serialisation and deserialisation of the value of the PropVariant data, but also includes a DataSize element to provide the length of the serialised data.
/// </summary>
/// <param name="info">The serialisation data</param>
/// <param name="context">Defines the source of the serialisation data</param>
public PropVariant(SerializationInfo info, StreamingContext context)
{
_ppv = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(PROPVARIANT)));
uint size = info.GetUInt32("DataSize");
byte[] serialized = (byte[])info.GetValue("Data", typeof(byte[]));
IntPtr data = Marshal.AllocCoTaskMem((int)size);
Marshal.Copy(serialized, 0, data, (int)size);
try {
HRESULT hr = StgDeserializePropVariant(data, size, _ppv);
if (hr.Failed)
{
throw hr.GetException();
}
}
catch {
Marshal.FreeCoTaskMem(data);
Marshal.FreeCoTaskMem(_ppv);
_ppv = IntPtr.Zero;
throw;
}
Marshal.FreeCoTaskMem(data);
MarshalPointerToValue();
}
public MemberExcluded(SerializationInfo info, StreamingContext context)
{
AggregateInstanceKey = info.GetString(nameof(AggregateInstanceKey));
AsOfDate = info.GetDateTime(nameof(AsOfDate));
AsOfSequenceNumber = info.GetUInt32(nameof(AsOfSequenceNumber));
Commentary = info.GetString(nameof(Commentary));
}
protected ISerializableTestObject(SerializationInfo info, StreamingContext context)
{
_stringValue = info.GetString("stringValue");
_intValue = info.GetInt32("intValue");
_dateTimeOffsetValue = (DateTimeOffset)info.GetValue(
"dateTimeOffsetValue",
typeof(DateTimeOffset)
);
_personValue = (Person)info.GetValue("personValue", typeof(Person));
_nullPersonValue = (Person)info.GetValue("nullPersonValue", typeof(Person));
_nullableInt = (int?)info.GetValue("nullableInt", typeof(int?));
_booleanValue = info.GetBoolean("booleanValue");
_byteValue = info.GetByte("byteValue");
_charValue = info.GetChar("charValue");
_dateTimeValue = info.GetDateTime("dateTimeValue");
_decimalValue = info.GetDecimal("decimalValue");
_shortValue = info.GetInt16("shortValue");
_longValue = info.GetInt64("longValue");
_sbyteValue = info.GetSByte("sbyteValue");
_floatValue = info.GetSingle("floatValue");
_ushortValue = info.GetUInt16("ushortValue");
_uintValue = info.GetUInt32("uintValue");
_ulongValue = info.GetUInt64("ulongValue");
}
public PropNotSetException(
SerializationInfo info, StreamingContext context) :
base(info, context)
{
pa = (PropertyAccessor)info.GetValue("pa", typeof(PropertyAccessor));
dwPropId = info.GetUInt32("dwPropId");
}
protected NativeTypes(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
throw new ArgumentNullException(nameof(info));
}
Bool = info.GetBoolean(nameof(Bool));
Byte = info.GetByte(nameof(Byte));
Sbyte = info.GetSByte(nameof(Sbyte));
Char = info.GetChar(nameof(Char));
Decimal = info.GetDecimal(nameof(Decimal));
Double = info.GetDouble(nameof(Double));
Float = info.GetSingle(nameof(Float));
Int = info.GetInt32(nameof(Int));
Uint = info.GetUInt32(nameof(Uint));
Long = info.GetInt64(nameof(Long));
Ulong = info.GetUInt64(nameof(Ulong));
Short = info.GetInt16(nameof(Short));
Ushort = info.GetUInt16(nameof(Ushort));
String = info.GetString(nameof(String));
DateTime = info.GetDateTime(nameof(DateTime));
Guid = Guid.Parse(info.GetString(nameof(Guid)));
Null = info.GetValue(nameof(Null), typeof(object));
}
public Data(SerializationInfo info, StreamingContext context)
{
_scores = ( int )info.GetValue("scores", typeof(int));
_level = ( int )info.GetUInt32("level");
_levelData = (List <KeyColorData>)info.GetValue("data", typeof(List <KeyColorData>));
_shapeData = (List <KeyColorData>)info.GetValue("shape", typeof(List <KeyColorData>));
}
public bool runTest()
{
Console.WriteLine(s_strTFPath + " " + s_strTFName + " , for " + s_strClassMethod + " , Source ver : " + s_strDtTmVer);
int iCountErrors = 0;
int iCountTestcases = 0;
String strLoc = "Loc_000oo";
SerializationInfo serinfo1 = null;
Boolean fValue;
Char chValue;
SByte sbtValue;
Byte btValue;
Int16 i16Value;
Int32 i32Value;
Int64 i64Value;
UInt16 ui16Value;
UInt32 ui32Value;
UInt64 ui64Value;
Double dblValue;
Single sglValue;
DateTime dtValue;
Decimal dcmValue;
StringBuilder sbldr1;
String strValue;
Random rnd1;
try {
do
{
strLoc="Loc_6573cd";
serinfo1 = new SerializationInfo(typeof(Int32), new FormatterConverter());
iCountTestcases++;
if(serinfo1.MemberCount != 0)
{
iCountErrors++;
Console.WriteLine("Err_0246sd! Wrong number of members, " + serinfo1.MemberCount.ToString());
}
strLoc="Loc_6853vd";
fValue = false;
serinfo1.AddValue("Boolean_1", fValue);
iCountTestcases++;
if(serinfo1.GetBoolean("Boolean_1") != fValue)
{
iCountErrors++;
Console.WriteLine("Err_0945csd! wrong value returned, " + serinfo1.GetBoolean("Boolean_1"));
}
fValue = true;
serinfo1.AddValue("Boolean_2", fValue);
iCountTestcases++;
if(serinfo1.GetBoolean("Boolean_2") != fValue)
{
iCountErrors++;
Console.WriteLine("Err_6753vd! wrong value returned, " + serinfo1.GetBoolean("Boolean_2"));
}
try {
iCountTestcases++;
serinfo1.AddValue("Boolean_2", fValue);
iCountErrors++;
Console.WriteLine("Err_1065753cd! Exception not thrown");
}catch(SerializationException){
}catch(Exception ex){
iCountErrors++;
Console.WriteLine("Err_5739cd! Wrong exception thrown, " + ex);
}
Console.WriteLine("Large String, ticks, " + Environment.TickCount);
sbldr1 = new StringBuilder("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
fValue = false;
serinfo1.AddValue(sbldr1.ToString(), fValue);
iCountTestcases++;
if(serinfo1.GetBoolean(sbldr1.ToString()) != fValue)
{
iCountErrors++;
Console.WriteLine("Err_6538fvd! wrong value returned, " + serinfo1.GetBoolean(sbldr1.ToString()));
}
try {
iCountTestcases++;
serinfo1.AddValue(null, fValue);
iCountErrors++;
Console.WriteLine("Err_0156ds! Exception not thrown");
}catch(ArgumentNullException){
}catch(Exception ex){
iCountErrors++;
Console.WriteLine("Err_57834fd! Wrong exception thrown, " + ex);
}
Console.WriteLine("Char ticks, " + Environment.TickCount);
rnd1 = new Random();
for(int i=0; i<50; i++) {
strLoc="Loc_6753cd_" + i;
chValue = (Char)(65536 * rnd1.NextDouble());
strValue = "Char_" + i;
serinfo1.AddValue(strValue, chValue);
iCountTestcases++;
if(serinfo1.GetChar(strValue)!= chValue)
{
iCountErrors++;
Console.WriteLine("Err_65730dsw_" + i + "! Wrong Char returned, " + serinfo1.GetChar(strValue));
}
}
try {
iCountTestcases++;
serinfo1.AddValue("Char_1", 'a');
iCountErrors++;
Console.WriteLine("Err_643cd! Exception not thrown");
}catch(SerializationException){
}catch(Exception ex){
iCountErrors++;
Console.WriteLine("Err_02457fd! Wrong exception thrown, " + ex);
}
try {
iCountTestcases++;
serinfo1.AddValue("Boolean_1", 'a');
iCountErrors++;
Console.WriteLine("Err_5732fcd! Exception not thrown");
}catch(SerializationException){
}catch(Exception ex){
iCountErrors++;
Console.WriteLine("Err_024568fd! Wrong exception thrown, " + ex);
}
Console.WriteLine("SByte ticks, " + Environment.TickCount);
for(int i=(int)SByte.MinValue; i<(int)SByte.MaxValue; i++) {
strLoc="Loc_56473vd_" + i;
sbtValue = (SByte)i;;
strValue = "SByte_" + i;
serinfo1.AddValue(strValue, sbtValue);
iCountTestcases++;
if(serinfo1.GetSByte(strValue)!= sbtValue)
{
iCountErrors++;
Console.WriteLine("Err_4627fds_" + i + "! Wrong Sbyte returned, " + serinfo1.GetSByte(strValue));
}
}
Console.WriteLine("Byte ticks, " + Environment.TickCount);
for(int i=(int)Byte.MinValue; i<(int)Byte.MaxValue; i++) {
strLoc="Loc_01192ds_" + i;
btValue = (Byte)i;;
strValue = "Byte_" + i;
serinfo1.AddValue(strValue, btValue);
iCountTestcases++;
if(serinfo1.GetByte(strValue)!= btValue)
{
iCountErrors++;
Console.WriteLine("Err_0267fe_" + i + "! Wrong byte returned, " + serinfo1.GetByte(strValue));
}
}
Console.WriteLine("Int16 ticks, " + Environment.TickCount);
for(int i=0; i<50; i++) {
strLoc="Loc_012965565ds_" + i;
i16Value = (short)((int)Int16.MaxValue * rnd1.NextDouble());
if(rnd1.NextDouble()<0.5)
i16Value = (short)(-1 * i16Value);
strValue = "Int16_" + i;
serinfo1.AddValue(strValue, i16Value);
iCountTestcases++;
if(serinfo1.GetInt16(strValue)!= i16Value)
{
iCountErrors++;
Console.WriteLine("Err_0267fe_" + i + "! Wrong value returned, " + serinfo1.GetInt16(strValue));
}
}
Console.WriteLine("Int32 ticks, " + Environment.TickCount);
for(int i=0; i<50; i++) {
strLoc="Loc_015643ds_" + i;
i32Value = (int)(Int32.MaxValue * rnd1.NextDouble());
if(rnd1.NextDouble()<0.5)
i32Value = (-1 * i32Value);
strValue = "Int32_" + i;
serinfo1.AddValue(strValue, i32Value);
iCountTestcases++;
if(serinfo1.GetInt32(strValue)!= i32Value)
{
iCountErrors++;
Console.WriteLine("Err_5427ds_" + i + "! Wrong value returned, " + serinfo1.GetInt32(strValue));
}
}
Console.WriteLine("Int64 ticks, " + Environment.TickCount);
for(int i=0; i<50; i++) {
strLoc="Loc_625bfg_" + i;
i64Value = (long)((long)Int64.MaxValue * rnd1.NextDouble());
if(rnd1.NextDouble()<0.5)
i64Value = (long)(-1 * i64Value);
strValue = "Int64_" + i;
serinfo1.AddValue(strValue, i64Value);
iCountTestcases++;
if(serinfo1.GetInt64(strValue)!= i64Value)
{
iCountErrors++;
Console.WriteLine("Err_6427dc_" + i + "! Wrong value returned, " + serinfo1.GetInt64(strValue));
}
}
Console.WriteLine("UInt16 ticks, " + Environment.TickCount);
for(int i=0; i<50; i++) {
strLoc="Loc_6473cd_" + i;
ui16Value = (ushort)((int)UInt16.MaxValue * rnd1.NextDouble());
strValue = "UInt16_" + i;
serinfo1.AddValue(strValue, ui16Value);
iCountTestcases++;
if(serinfo1.GetUInt16(strValue)!= ui16Value)
{
iCountErrors++;
Console.WriteLine("Err_748vd_" + i + "! Wrong value returned, " + serinfo1.GetUInt16(strValue));
}
}
Console.WriteLine("UInt32 ticks, " + Environment.TickCount);
for(int i=0; i<50; i++) {
strLoc="Loc_7573cd_" + i;
ui32Value = (uint)(UInt32.MaxValue * rnd1.NextDouble());
strValue = "UInt32_" + i;
serinfo1.AddValue(strValue, ui32Value);
iCountTestcases++;
if(serinfo1.GetUInt32(strValue)!= ui32Value)
{
iCountErrors++;
Console.WriteLine("Err_4738cd_" + i + "! Wrong value returned, " + serinfo1.GetUInt32(strValue));
}
}
Console.WriteLine("UInt64 ticks, " + Environment.TickCount);
for(int i=0; i<50; i++) {
strLoc="Loc_63dc_" + i;
ui64Value = (ulong)(UInt64.MaxValue * rnd1.NextDouble());
strValue = "UInt64_" + i;
serinfo1.AddValue(strValue, ui64Value);
iCountTestcases++;
if(serinfo1.GetUInt64(strValue)!= ui64Value)
{
iCountErrors++;
Console.WriteLine("Err_6583fd_" + i + "! Wrong value returned, " + serinfo1.GetUInt64(strValue));
}
}
Console.WriteLine("Double ticks, " + Environment.TickCount);
for(int i=0; i<50; i++) {
strLoc="Loc_7539cd_" + i;
dblValue = Double.MaxValue * rnd1.NextDouble();
if(rnd1.NextDouble()<0.5)
dblValue = (-1 * dblValue);
strValue = "Double_" + i;
serinfo1.AddValue(strValue, dblValue);
iCountTestcases++;
if(serinfo1.GetDouble(strValue)!= dblValue)
{
iCountErrors++;
Console.WriteLine("Err_653cfd_" + i + "! Wrong value returned, " + serinfo1.GetDouble(strValue));
}
}
Console.WriteLine("Single ticks, " + Environment.TickCount);
for(int i=0; i<50; i++) {
strLoc="Loc_0247fd_" + i;
sglValue = (float)(Single.MaxValue * rnd1.NextDouble());
if(rnd1.NextDouble()<0.5)
sglValue = (-1 * sglValue);
strValue = "Single_" + i;
serinfo1.AddValue(strValue, sglValue);
iCountTestcases++;
if(serinfo1.GetSingle(strValue)!= sglValue)
{
iCountErrors++;
Console.WriteLine("Err_0468fd_" + i + "! Wrong value returned, " + serinfo1.GetSingle(strValue));
}
}
strValue = "This is a String";
serinfo1.AddValue("String_1", strValue);
iCountTestcases++;
if(!serinfo1.GetString("String_1").Equals(strValue))
{
iCountErrors++;
Console.WriteLine("Err_0945csd! wrong value returned, " + serinfo1.GetString("String_1"));
}
strValue = "";
serinfo1.AddValue("String_2", strValue);
iCountTestcases++;
if(!serinfo1.GetString("String_2").Equals(String.Empty))
{
iCountErrors++;
Console.WriteLine("Err_0945csd! wrong value returned, " + serinfo1.GetString("String_2"));
}
strValue = null;
serinfo1.AddValue("String_3", strValue);
iCountTestcases++;
if(serinfo1.GetString("String_3") != null)
{
iCountErrors++;
Console.WriteLine("Err_0945csd! wrong value returned, " + serinfo1.GetString("String_3"));
}
try {
iCountTestcases++;
serinfo1.AddValue("String_2", fValue);
iCountErrors++;
Console.WriteLine("Err_1065753cd! Exception not thrown");
}catch(SerializationException){
}catch(Exception ex){
iCountErrors++;
Console.WriteLine("Err_5739cd! Wrong exception thrown, " + ex);
}
Console.WriteLine("Single ticks, " + Environment.TickCount);
for(int i=0; i<50; i++) {
strLoc="Loc_0247fd_" + i;
dblValue = (double)(DateTime.MaxValue.ToOADate() * rnd1.NextDouble());
strValue = "DateTime_" + i;
dtValue = DateTime.FromOADate(dblValue);
serinfo1.AddValue(strValue, dtValue);
iCountTestcases++;
if(serinfo1.GetDateTime(strValue)!= dtValue)
{
iCountErrors++;
Console.WriteLine("Err_0468fd_" + i + "! Wrong value returned, " + serinfo1.GetDateTime(strValue));
}
}
for(int i=0; i<50; i++) {
strLoc="Loc_0247fd_" + i;
dcmValue = (Decimal)((double)Decimal.MaxValue * rnd1.NextDouble());
if(rnd1.NextDouble()<0.5)
dcmValue = (Decimal)(-1 * dcmValue);
strValue = "Decimal_" + i;
serinfo1.AddValue(strValue, dcmValue);
iCountTestcases++;
if(serinfo1.GetDecimal(strValue)!= dcmValue)
{
iCountErrors++;
Console.WriteLine("Err_2342fdsg_" + i + "! Wrong value returned, " + serinfo1.GetDecimal(strValue));
}
}
} while (false);
} catch (Exception exc_general ) {
++iCountErrors;
Console.WriteLine (s_strTFAbbrev + " : Error Err_8888yyy! strLoc=="+ strLoc +", exc_general==\n"+exc_general.StackTrace);
}
if ( iCountErrors == 0 )
{
Console.WriteLine( "paSs. "+s_strTFPath +" "+s_strTFName+" ,iCountTestcases=="+iCountTestcases.ToString());
return true;
}
else
{
Console.WriteLine("FAiL! "+s_strTFPath+" "+s_strTFName+" ,iCountErrors=="+iCountErrors.ToString()+" , BugNums?: "+s_strActiveBugNums );
return false;
}
}
