Example #1
0
        protected Phenotype(SerializationInfo info, StreamingContext context)
        {
            _genotype   = (Genotype <TGene>)info.GetValue("_genotype", typeof(Genotype <TGene>));
            _generation = info.GetInt64("_generation");

            _rawFitness = new Lazy <TAllele>((TAllele)info.GetValue("_rawFitness", typeof(TAllele)));
            _fitness    = new Lazy <TAllele>((TAllele)info.GetValue("_fitness", typeof(TAllele)));

            _function = a => default;
            _scaler   = a => a;
        }
Example #2
0
 protected Map(SerializationInfo info, StreamingContext context)
 {
     if (info == null)
     {
         throw new ArgumentNullException("info");
     }
     mapname = info.GetString(KEY_MAPNAME);
     created = new DateTime(info.GetInt64(KEY_CREATED));
     chunks  = (List <Chunk>)info.GetValue(KEY_CHUNKS, typeof(List <Chunk>));
     for (int a = 0; a < chunks.Count; a++)
     {
         chunks [a].map = this;
     }
     players = (List <Player>)info.GetValue(KEY_PLAYERS, typeof(List <Player>));
     for (int a = 0; a < players.Count; a++)
     {
         players [a].chunk = getChunk(players [a].getChunkX(), players [a].getChunkZ());
     }
     time = info.GetInt64(KEY_TIME);
 }
Example #3
0
 protected HttpWebResponse(SerializationInfo serializationInfo, StreamingContext streamingContext)
 {
     uri               = (Uri)serializationInfo.GetValue("uri", typeof(Uri));
     contentLength     = serializationInfo.GetInt64("contentLength");
     contentType       = serializationInfo.GetString("contentType");
     method            = serializationInfo.GetString("method");
     statusDescription = serializationInfo.GetString("statusDescription");
     cookieCollection  = (CookieCollection)serializationInfo.GetValue("cookieCollection", typeof(CookieCollection));
     version           = (Version)serializationInfo.GetValue("version", typeof(Version));
     statusCode        = (HttpStatusCode)(int)serializationInfo.GetValue("statusCode", typeof(HttpStatusCode));
 }
Example #4
0
 public Kupac(SerializationInfo info, StreamingContext context)
 {
     ime           = info.GetString("ime");
     prezime       = info.GetString("prezime");
     korisnickoIme = info.GetString("korisicko_ime");
     lozinka       = info.GetString("lozinka");
     datumRodjenja = info.GetString("datumRodjenja");
     idbr          = info.GetInt32("idbr");
     jmbg          = info.GetInt64("jmbg");
     telefon       = info.GetString("telefon");
 }
Example #5
0
 protected FileWebRequest(SerializationInfo serializationInfo, StreamingContext streamingContext) : base(serializationInfo, streamingContext)
 {
     m_headers             = (WebHeaderCollection)serializationInfo.GetValue("headers", typeof(WebHeaderCollection));
     m_proxy               = (IWebProxy)serializationInfo.GetValue("proxy", typeof(IWebProxy));
     m_uri                 = (Uri)serializationInfo.GetValue("uri", typeof(Uri));
     m_connectionGroupName = serializationInfo.GetString("connectionGroupName");
     m_method              = serializationInfo.GetString("method");
     m_contentLength       = serializationInfo.GetInt64("contentLength");
     m_timeout             = serializationInfo.GetInt32("timeout");
     m_fileAccess          = (FileAccess )serializationInfo.GetInt32("fileAccess");
 }
Example #6
0
 protected OAuth2AccessToken(SerializationInfo info, StreamingContext context) : base(info, context)
 {
     if (info == null)
     {
         throw new ArgumentNullException("info");
     }
     this.ExpiresIn    = info.GetInt64("ExpiresIn");
     this.RefreshToken = info.GetString("RefreshToken");
     this.Scope        = info.GetString("Scope");
     this.TokenType    = info.GetString("TokenType");
 }
Example #7
0
 /// <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[];
 }
Example #8
0
        private unsafe IntPtr(SerializationInfo info, StreamingContext context)
        {
            long l = info.GetInt64("value");

            if (Size == 4 && (l > int.MaxValue || l < int.MinValue))
            {
                throw new ArgumentException(SR.Serialization_InvalidPtrValue);
            }

            _value = (void *)l;
        }
Example #9
0
        private unsafe IntPtr(SerializationInfo info, StreamingContext context)
        {
            long l = info.GetInt64("value");

            if (Size == 4 && (l > Int32.MaxValue || l < Int32.MinValue))
            {
                throw new ArgumentException(Environment.GetResourceString("Serialization_InvalidPtrValue"));
            }

            m_value = (void *)l;
        }
Example #10
0
        private VideoFile(SerializationInfo info, DeserializeInfo di)
            : this(di.Server, di.Info, di.Type)
        {
            actors      = info.GetValue("a", typeof(string[])) as string[];
            description = info.GetString("de");
            director    = info.GetString("di");
            genre       = info.GetString("g");
            title       = info.GetString("t");
            try
            {
                width  = info.GetInt32("w");
                height = info.GetInt32("h");
            }
            catch (Exception)
            {
                // ignored
            }
            var ts = info.GetInt64("du");

            if (ts > 0)
            {
                duration = new TimeSpan(ts);
            }
            try
            {
                bookmark = info.GetInt64("b");
            }
            catch (Exception)
            {
                bookmark = 0;
            }
            try
            {
                subTitle = info.GetValue("st", typeof(Subtitle)) as Subtitle;
            }
            catch (Exception)
            {
                subTitle = null;
            }
            initialized = true;
        }
Example #11
0
        protected TimeZoneResponse(SerializationInfo info, StreamingContext context)
        {
            if (info is null)
            {
                throw new ArgumentNullException(nameof(info));
            }

            Status = info.GetString(STATUS_FIELD).MapToStatusCode();

            if (Status == HttpStatusCode.OK)
            {
                DstOffset    = info.GetInt64(DST_OFFSET_FIELD);
                RawOffset    = info.GetInt64(RAW_OFFSET_FIELD);
                TimeZoneId   = info.GetString(TIME_ZONE_ID_FIELD);
                TimeZoneName = info.GetString(TIME_ZONE_NAME_FIELD);
            }
            else if (Status != HttpStatusCode.NoContent)
            {
                ErrorMessage = info.GetString(ERROR_MESSAGE_FIELD);
            }
        }
Example #12
0
        /// <summary>
        /// Constructor for deserialization.
        /// </summary>
        /// <param name="info">Serialization Info.</param>
        /// <param name="context">Streaming context.</param>
        protected PersistentMultiWaySuffixEdge(SerializationInfo info, StreamingContext context)
        {
            if (info == null)
            {
                throw new ArgumentNullException("info");
            }

            Key        = info.GetInt64("PersistentMultiWaySuffixEdge:Key");
            _children  = (long[])info.GetValue("PersistentMultiWaySuffixEdge:Children", typeof(long[]));
            StartIndex = info.GetInt32("PersistentMultiWaySuffixEdge:StartIndex");
            EndIndex   = info.GetInt32("PersistentMultiWaySuffixEdge:EndIndex");
        }
Example #13
0
 protected HttpWebResponse(SerializationInfo serializationInfo, StreamingContext streamingContext) : base(serializationInfo, streamingContext)
 {
     this.m_HttpResponseHeaders = (WebHeaderCollection)serializationInfo.GetValue("m_HttpResponseHeaders", typeof(WebHeaderCollection));
     this.m_Uri               = (Uri)serializationInfo.GetValue("m_Uri", typeof(Uri));
     this.m_Certificate       = (X509Certificate)serializationInfo.GetValue("m_Certificate", typeof(X509Certificate));
     this.m_IsVersionHttp11   = ((Version)serializationInfo.GetValue("m_Version", typeof(Version))).Equals(HttpVersion.Version11);
     this.m_StatusCode        = (HttpStatusCode)serializationInfo.GetInt32("m_StatusCode");
     this.m_ContentLength     = serializationInfo.GetInt64("m_ContentLength");
     this.m_Verb              = KnownHttpVerb.Parse(serializationInfo.GetString("m_Verb"));
     this.m_StatusDescription = serializationInfo.GetString("m_StatusDescription");
     this.m_MediaType         = serializationInfo.GetString("m_MediaType");
 }
        private BooleanPointer(SerializationInfo info, StreamingContext context)
        {
            long num = info.GetInt64("value");

            if ((Size == Constants.X86PlatformPtrSize) &&
                ((num > Constants.X86UpperBound) || (num < Constants.X86LowerBound)))
            {
                throw new Exception("Invalid pointer value.");
            }

            this.internalPointer = (bool *)num;
        }
Example #15
0
 /// <summary>
 /// Creates a new <see cref="ChannelFrameBase{T}"/> 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 ChannelFrameBase(SerializationInfo info, StreamingContext context)
 {
     // Deserialize key frame elements...
     m_idCode             = info.GetUInt16("idCode");
     m_cells              = (IChannelCellCollection <T>)info.GetValue("cells", typeof(IChannelCellCollection <T>));
     m_timestamp          = info.GetInt64("timestamp");
     m_lifespan           = ShortTime.Now;
     m_trustHeaderLength  = true;
     m_validateCheckSum   = true;
     m_measurements       = new ConcurrentDictionary <MeasurementKey, IMeasurement>();
     m_sortedMeasurements = -1;
 }
Example #16
0
 protected FileWebRequest(SerializationInfo serializationInfo, StreamingContext streamingContext)
 {
     webHeaders      = (WebHeaderCollection)serializationInfo.GetValue("headers", typeof(WebHeaderCollection));
     proxy           = (IWebProxy)serializationInfo.GetValue("proxy", typeof(IWebProxy));
     uri             = (Uri)serializationInfo.GetValue("uri", typeof(Uri));
     connectionGroup = serializationInfo.GetString("connectionGroupName");
     method          = serializationInfo.GetString("method");
     contentLength   = serializationInfo.GetInt64("contentLength");
     timeout         = serializationInfo.GetInt32("timeout");
     fileAccess      = (FileAccess)(int)serializationInfo.GetValue("fileAccess", typeof(FileAccess));
     preAuthenticate = serializationInfo.GetBoolean("preauthenticate");
 }
 /// <summary>
 /// Initializes a new instance of the MalformedLineException class with serialized data.
 /// </summary>
 /// <param name="info">The SerializationInfo object that holds the serialized 
 /// object data about the exception being thrown.</param>
 /// <param name="context">The StreamingContext structure that contains contextual 
 /// information about the source or destination.</param>
 protected MalformedLineException(SerializationInfo info, StreamingContext context)
     : base(info, context)
 {
     if (info != null)
     {
         this.lineNumber = info.GetInt64("LineNumber");
     }
     else
     {
         this.lineNumber = -1;
     }
 }
Example #18
0
 protected OAuth2Client(SerializationInfo info, StreamingContext context)
 {
     this.clientKey      = info.GetString(nameof(this.clientKey));
     this.secretKey      = info.GetString(nameof(this.secretKey));
     this.oauth2Code     = info.GetString(nameof(this.oauth2Code));
     this.accessToken    = info.GetString(nameof(this.accessToken));
     this.refleshToken   = info.GetString(nameof(this.refleshToken));
     this.tokenExpired   = info.GetInt64(nameof(this.tokenExpired));
     this.tokenQueryTime = info.GetDateTime(nameof(this.tokenQueryTime));
     this.redirectUri    = info.GetString(nameof(this.redirectUri));
     this.scope          = info.GetString(nameof(this.scope));
 }
Example #19
0
            protected Primitives(SerializationInfo info, StreamingContext context)
            {
                SerializationCtorCalled = true;

                Byte  = info.GetByte("byte");
                Bytes = (byte[])info.GetValue("bytes", typeof(byte[]));

                Sbyte  = info.GetSByte("sbyte");
                Sbytes = (sbyte[])info.GetValue("sbytes", typeof(sbyte[]));

                Bool  = info.GetBoolean("bool");
                Bools = (bool[])info.GetValue("bools", typeof(bool[]));

                Char  = info.GetChar("char");
                Chars = (char[])info.GetValue("chars", typeof(char[]));

                Short  = info.GetInt16("short");
                Shorts = (short[])info.GetValue("shorts", typeof(short[]));

                Ushort  = info.GetUInt16("ushort");
                Ushorts = (ushort[])info.GetValue("ushorts", typeof(ushort[]));

                Int  = info.GetInt32("int");
                Ints = (int[])info.GetValue("ints", typeof(int[]));

                Uint  = info.GetUInt32("uint");
                Uints = (uint[])info.GetValue("uints", typeof(uint[]));

                Long  = info.GetInt64("long");
                Longs = (long[])info.GetValue("longs", typeof(long[]));

                Ulong  = info.GetUInt64("ulong");
                Ulongs = (ulong[])info.GetValue("ulongs", typeof(ulong[]));

                Float  = info.GetSingle("float");
                Floats = (float[])info.GetValue("floats", typeof(float[]));

                Double  = info.GetDouble("double");
                Doubles = (double[])info.GetValue("doubles", typeof(double[]));

                Decimal  = info.GetDecimal("decimal");
                Decimals = (decimal[])info.GetValue("decimals", typeof(decimal[]));

                Guid  = (Guid)info.GetValue("guid", typeof(Guid));
                Guids = (Guid[])info.GetValue("guids", typeof(Guid[]));

                DateTime  = info.GetDateTime("datetime");
                DateTimes = (DateTime[])info.GetValue("datetimes", typeof(DateTime[]));

                String  = info.GetString("string");
                Strings = (string[])info.GetValue("strings", typeof(string[]));
            }
Example #20
0
        /// <summary>
        /// Creates a new <see cref="ConfigurationCell"/> 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 ConfigurationCell(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
            // Create a cached signal reference dictionary for generated signal references
            m_generatedSignalReferenceCache = new string[Enum.GetValues(typeof(SignalKind)).Length][];

            // Deserialize configuration cell
            m_lastReportTime         = info.GetInt64("lastReportTime");
            m_analogDataFormat       = (DataFormat)info.GetValue("analogDataFormat", typeof(DataFormat));
            m_frequencyDataFormat    = (DataFormat)info.GetValue("frequencyDataFormat", typeof(DataFormat));
            m_phasorDataFormat       = (DataFormat)info.GetValue("phasorDataFormat", typeof(DataFormat));
            m_phasorCoordinateFormat = (CoordinateFormat)info.GetValue("phasorCoordinateFormat", typeof(CoordinateFormat));
        }
Example #21
0
        /// <summary>
        /// Constructor for deserialization.
        /// </summary>
        /// <param name="info">Serialization Info.</param>
        /// <param name="context">Streaming context.</param>
        protected Hit(SerializationInfo info, StreamingContext context)
        {
            if (info == null)
            {
                throw new ArgumentNullException("info");
            }

            _hsps     = (IList <Hsp>)info.GetValue("Hit:Hsps", typeof(IList <Hsp>));
            Id        = info.GetString("Hit:Id");
            Def       = info.GetString("Hit:Def");
            Accession = info.GetString("Hit:Accession");
            Length    = info.GetInt64("Hit:Length");
        }
 protected ArchiveFileInfo(SerializationInfo info, StreamingContext context)
     : base(info, context)
 {
     archiveInfo   = (ArchiveInfo)info.GetValue("archiveInfo", typeof(ArchiveInfo));
     name          = info.GetString("name");
     path          = info.GetString("path");
     initialized   = info.GetBoolean("initialized");
     exists        = info.GetBoolean("exists");
     archiveNumber = info.GetInt32("archiveNumber");
     attributes    = (FileAttributes)info.GetValue("attributes", typeof(FileAttributes));
     lastWriteTime = info.GetDateTime("lastWriteTime");
     length        = info.GetInt64("length");
 }
Example #23
0
 public SimpleSerializable(SerializationInfo info, StreamingContext context)
 {
     Byte    = info.GetByte("Byte");
     Bool    = info.GetBoolean("Bool");
     Short   = info.GetInt16("Short");
     Int     = info.GetInt32("Int");
     Long    = info.GetInt64("Long");
     Float   = info.GetSingle("Float");
     Double  = info.GetDouble("Double");
     Decimal = info.GetDecimal("Decimal");
     Guid    = (Guid)info.GetValue("Guid", typeof(Guid));
     String  = info.GetString("String");
 }
Example #24
0
        /// <summary>
        /// Serialization constructor used for deserialization
        /// </summary>
        /// <param name="info">The serialization info</param>
        /// <param name="context">The context of the stream</param>
        protected DomainEntityBase(SerializationInfo info, StreamingContext context)
        {
            Id                   = (TIdType)info.GetValue("Id", typeof(TIdType));
            ExternalId           = info.GetString("ExternalId");
            Culture              = info.GetString("Culture");
            Name                 = info.GetString("DisplayName");
            DescriptionShort     = info.GetString("DescriptionShort");
            DescriptionFull      = info.GetString("DescriptionFull");
            Tags                 = (IEnumerable <MetadataTag>)info.GetValue("Metadata", typeof(IEnumerable <MetadataTag>));
            CreationTime         = info.GetDateTime("CreationTime");
            CreatorUserId        = info.GetInt64("CreatorUserId");
            LastModificationTime = info.GetDateTime("LastModificationTime");
            LastModifierUserId   = info.GetInt64("LastModifierUserId");
            IsDeleted            = info.GetBoolean("IsDeleted");
            DeleterUserId        = info.GetInt64("DeleterUserId");
            DeletionTime         = info.GetDateTime("DeletionTime");
            IsActive             = info.GetBoolean("IsActive");
            TranslatedFromId     = (TIdType)info.GetValue("TranslatedFromId", typeof(TIdType));
            SeqNum               = info.GetInt32("SeqNum");

            //Metadata = (MetadataInformation)info.GetValue("Metadata", typeof(MetadataInformation));
        }
Example #25
0
        object ISerializationSurrogate.SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
        {
            TokenResponse token = (TokenResponse)obj;

            token.AccessToken      = info.GetString("AccessToken");
            token.ExpiresInSeconds = info.GetInt64("ExpiresInSeconds");
            token.Issued           = info.GetDateTime("Issued");
            token.RefreshToken     = info.GetString("RefreshToken");
            token.Scope            = info.GetString("Scope");
            token.TokenType        = info.GetString("TokenType");

            return(token);
        }
Example #26
0
        /// <summary>
        /// Initializes a new instance of the <see cref="HttpOutcome"/> class.
        /// </summary>
        /// <param name="info">
        /// The information.
        /// </param>
        /// <param name="context">
        /// The context.
        /// </param>
        /// <exception cref="ArgumentNullException">
        /// The <paramref name="info"/> is <c>null</c>.
        /// </exception>
        protected HttpOutcome(SerializationInfo info, StreamingContext context)
        {
            if (info == null)
            {
                throw new ArgumentNullException("info");
            }

            _location        = new Uri(info.GetString("Location"));
            _method          = new HttpMethod(info.GetString("Method"));
            _statusCode      = (HttpStatusCode)Enum.Parse(typeof(HttpStatusCode), info.GetString("StatusCode"));
            _responseMessage = info.GetString("ResonseMessage");
            _responseTime    = new TimeSpan(info.GetInt64("ResonseTime"));
        }
Example #27
0
        private IntPtr(SerializationInfo info, StreamingContext context)
        {
            long value = info.GetInt64("value");

#if TARGET_32BIT
            if ((value > int.MaxValue) || (value < int.MinValue))
            {
                throw new ArgumentException(SR.Serialization_InvalidPtrValue);
            }
#endif

            _value = (nint)value;
        }
Example #28
0
        /// <summary>
        /// Конструктор вызываемый при десериализации объекта
        /// </summary>
        internal Parameter(SerializationInfo info, StreamingContext context)
        {
            if (info != null)
            {
                locker = new ReaderWriterLock();

                device = info.GetInt64(deviceSName);
                offset = info.GetInt64(offsetSName);

                size     = info.GetInt64(sizeSName);
                position = info.GetInt64(positionSName);

                type = (ParameterType)Enum.Parse(typeof(ParameterType), info.GetString(typeSName));
                desc = info.GetString(descSName);

                identifier = (Guid)info.GetValue(identifierSName, typeof(Guid));
                actual     = info.GetInt64(actualSName);
            }
            else
            {
                throw new ArgumentNullException("info");
            }
        }
Example #29
0
 /*
  *  ISerializable constructor
  */
 protected Regex(SerializationInfo info, StreamingContext context)
     : this(info.GetString("pattern"), (RegexOptions)info.GetInt32("options"))
 {
     try {
         Int64    timeoutTicks = info.GetInt64("matchTimeout");
         TimeSpan timeout      = new TimeSpan(timeoutTicks);
         ValidateMatchTimeout(timeout);
         this.internalMatchTimeout = timeout;
     } catch (SerializationException) {
         // If this occurs, then assume that this object was serialised using a version
         // before timeout was added. In that case just do not set a timeout
         // (keep default value)
     }
 }
        protected SimplifiedSvnChangeItem(SerializationInfo info, StreamingContext context)
        {
            Revision         = info.GetInt64("rev");
            CopyFromRevision = info.GetInt64("cfr");
            Path             = info.GetString("path");
            CopyFromPath     = info.GetString("cfp");
            byte nodki = info.GetByte("nodki");
            byte act   = info.GetByte("act");

            switch (nodki)
            {
            case 1: NodeKind = SvnNodeKind.Directory; break;

            case 2: NodeKind = SvnNodeKind.File; break;

            case 3: NodeKind = SvnNodeKind.SymbolicLink; break;

            case 4: NodeKind = SvnNodeKind.None; break;

            case 5: NodeKind = SvnNodeKind.Unknown; break;

            default: NodeKind = SvnNodeKind.Unknown; break;
            }

            switch (act)
            {
            case 1: Action = SvnChangeAction.Add; break;

            case 2: Action = SvnChangeAction.Modify; break;

            case 3: Action = SvnChangeAction.Replace; break;

            case 4: Action = SvnChangeAction.Delete; break;

            default: Action = SvnChangeAction.None; break;
            }
        }
Example #31
0
	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;
		}
	}
 /// <summary>
 /// Constructors a ParameterBindingException using serialized data.
 /// </summary>
 /// 
 /// <param name="info"> 
 /// serialization information 
 /// </param>
 /// 
 /// <param name="context"> 
 /// streaming context 
 /// </param>
 protected ParameterBindingException(
     SerializationInfo info,
     StreamingContext context)
     : base(info, context)
 {
     _message = info.GetString("ParameterBindingException_Message");
     _parameterName = info.GetString("ParameterName");
     _line = info.GetInt64("Line");
     _offset = info.GetInt64("Offset");
 }