/// <summary>
        /// Generate a random string of characters
        /// </summary>
        /// <param name="length">length of string</param>
        /// <param name="type">type of string to be generated</param>
        /// <returns></returns>
        public static string GenerateRandomString(int length, StringType type)
        {
            switch (type)
            {
                case StringType.AlphaNumeric:
                    string allowedChars = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ0123456789";
                    char[] chars = new char[length];
                    Random rd = new Random();

                    for (int i = 0; i < length; i++)
                    {
                        chars[i] = allowedChars[rd.Next(0, allowedChars.Length)];
                    }

                    return new string(chars);
                    break;

                case StringType.AlphaNumericSymbol:
                    //Generate a cryptographic random number.
                    var rng = new RNGCryptoServiceProvider();
                    var buff = new byte[length];
                    rng.GetBytes(buff);

                    rng.Dispose();

                    // Return a Base64 string representation of the random number.
                    return Convert.ToBase64String(buff);
                    break;
                default:
                    throw new ArgumentException("Type not supported");
            }
        }

 public virtual void ShouldDecodeLongString()
 {
     var stringType = new StringType();
     var longString = "MonkeyVeryLongStringmljalkdjflksjf lkdfjlsfjalkfjlsflskfjlsflsfjasdfjlsjflksfjlskjf fjlskfjlsjfs fkj lakdflsjfsa fafd sa";
     var result = stringType.Encode(longString);
     Assert.Equal(longString, stringType.Decode<string>(result));
 }

        /// <summary>
        ///   Validates given string for the given type.
        /// </summary>
        /// <param name="stringToValidate"> string to be validated. </param>
        /// <param name="type"> Type of the string. </param>
        /// <returns> True if string validates the required parameter </returns>
        public static bool Validate(string stringToValidate, StringType type)
        {
            if (null == stringToValidate)
            {
                ExceptionManager.Throw(new ArgumentNullException("stringToValidate"));
            }

            bool result = false;
            switch (type)
            {
                case StringType.Name:
                    result = ValidateName(stringToValidate);
                    break;
                case StringType.EmailAddress:
                    result = ValidateEmailAddress(stringToValidate);
                    break;
                case StringType.Address:
                    break;
                case StringType.Password:
                    result = ValidatePassword(stringToValidate);
                    break;
                default:
                    ExceptionManager.Throw(new ArgumentOutOfRangeException("type"));
                    break;
            }
            return result;
        }

 internal extern static bool CertStrToName(CertEncodingType dwCertEncodingType,
                                             [MarshalAs(UnmanagedType.LPWStr)]string pszX500,
                                             StringType dwStrType,
                                             IntPtr pvReserved,
                                             byte[] pbEncoded,
                                             [In, Out]ref int pcbEncoded,
                                             [MarshalAs(UnmanagedType.LPWStr)]ref StringBuilder ppszError);

 public UnsynchronisedLyricsFrame(string description, string language, StringType encoding) : base(FrameType.USLT, 4)
 {
     this.encoding = TagLib.Id3v2.Tag.DefaultEncoding;
     this.encoding = encoding;
     this.language = language;
     this.description = description;
 }

		public StringData(string name, uint offset, uint address, StringType type, string value, int size, uint pluginLine)
			: base(name, offset, address, pluginLine)
		{
			_value = value;
			_size = size;
			_type = type;
		}

 public CommentsFrame(string description, string language, StringType encoding) : base(FrameType.COMM, 4)
 {
     this.encoding = TagLib.Id3v2.Tag.DefaultEncoding;
     this.encoding = encoding;
     this.language = language;
     this.description = description;
 }

 public SynchronisedLyricsFrame (string description, string language, SynchedTextType type, StringType encoding) : base (FrameType.SYLT, 4)
 {
    this.text_encoding = encoding;
    this.language      = language;
    this.description   = description;
    this.lyrics_type   = type;
 }

		private void ParseCommentsFields(ByteVector data)
		{
			if (data.Count < 5)
			{
				TagLibDebugger.Debug("A comment frame must contain at least 5 bytes.");
				return;
			}

			textEncoding = (StringType)data[0];
			language = data.Mid(1, 3);

			int byte_align = textEncoding == StringType.Latin1 || textEncoding == StringType.UTF8 ? 1 : 2;

			ByteVectorCollection l = ByteVectorCollection.Split(data.Mid(4), TextDelimiter(textEncoding), byte_align, 2);

			if (l.Count == 2)
			{
				if (l[0].Data != null && l[0].Data.Count > 0)
					description = l[0].ToString(textEncoding);
				else description = string.Empty;
				
				if (l[1].Data != null && l[1].Data.Count > 0)
					text = l[1].ToString(textEncoding);
				else text = string.Empty;
			}
		}

		public Id3v2CommentsFrame(StringType encoding) : base("COMM")
		{
			textEncoding = encoding;
			//language = null;
			//fields = null;
			//type = null;
		}

 public IEnumerable<ProgramAddress> FindStrings(StringType stringType, int minLength)
 {
     foreach (var segment in program.ImageMap.Segments.Values)
     {
         Address segEnd = segment.Address + segment.Size;
         var rdr = program.Architecture.CreateImageReader(program.Image, segment.Address);
         Address addrStartRun = null;
         int cValid = 0;
         while (rdr.Address < segEnd)
         {
             byte ch = rdr.ReadByte();
             if (!IsValid((char)ch))
             {
                 if (ch == 0 && cValid >= minLength)
                 {
                     yield return new ProgramAddress(program, addrStartRun);
                 }
                 addrStartRun = null;
                 cValid = 0;
             }
             else
             {
                 if (addrStartRun == null)
                     addrStartRun = rdr.Address - 1;
                 ++cValid;
             }
         }
     }
 }

 protected static StringType CorrectEncoding(StringType type, byte version)
 {
     if (TagLib.Id3v2.Tag.ForceDefaultEncoding)
     {
         type = TagLib.Id3v2.Tag.DefaultEncoding;
     }
     return (((version >= 4) || (type != StringType.UTF8)) ? type : StringType.UTF16);
 }

        public StringContentTokenizer(StringType properties, char terminator, char openingParenthesis) {
            Debug.Assert(!Tokenizer.IsLetterOrDigit(terminator));

            _properties = properties;
            _terminator = terminator;
            _openingParenthesis = openingParenthesis;
            _nestingLevel = 0;
        }

        public StringFeatureAttribute(StringType splitType, string separator = " ", string exclusions = null)
        {
            SplitType = splitType;
            Separator = separator;
            ExclusionFile = exclusions;

            CalculateExclusions();
        }

        public void WriteTomlStrings(StringType s, string expected)
        {
            // Act
            var written = Toml.WriteString(s);

            // Assert
            Assert.Equal(expected, written.Trim());
        }

 public SynchronisedLyricsFrame(string description, string language, SynchedTextType type, StringType encoding) : base(FrameType.SYLT, 4)
 {
     this.encoding = TagLib.Id3v2.Tag.DefaultEncoding;
     this.text = new SynchedText[0];
     this.encoding = encoding;
     this.language = language;
     this.description = description;
     this.lyrics_type = type;
 }

        public string GetRandomString(StringType type, int length)
        {
            string result = string.Empty;
            if ((!type.Equals(StringType.None)) && (length > 0))
            {
                int charcode = 0;

                char[] chars = new char[length];

                for (int i = 0; i < length; i++)
                {
                    switch (type)
                    {
                        case StringType.Unicode:
                            charcode = GetUnicodeCharacterValue();
                            break;
                        case StringType.Alpha:
                            charcode = 65 + valueGen.Next(0, 26);
                            break;
                        case StringType.AlphaNumeric:
                            charcode = valueGen.Next(0, 36);
                            if (charcode < 10)
                            {
                                charcode += 48;
                            }
                            else
                            {
                                charcode += 55;
                            }
                            break;
                        case StringType.Numeric:
                            charcode = 48 + valueGen.Next(0, 10);
                            break;
                        case StringType.Cased:
                            charcode = valueGen.Next(0, 52);
                            if (charcode < 26)
                            {
                                charcode += 65;
                            }
                            else
                            {
                                charcode += 71;
                            }
                            break;
                    }
                    chars[i] = (char)charcode;
                }
                for (int i = 0; i < chars.Length; i++)
                {
                    result += chars[i].ToString();
                }
                chars = null;
            }

            return result;
        }

        public void StringTypeNames()
        {
            var expected = new[]
            {
                "System.String", "System.Char"
            };

            var actual = new StringType().TypeNames;
            TestHelper.AreEqual(expected, actual);
        }

        public string Get(string url, WebProxy proxy, string publicKey, string secretKey, string projectId, StringType type, int rate, string remarks = "")
        {
            using (var client = new WebClient())
            {
                if (proxy != null)
                    client.Proxy = proxy;
                client.Encoding = Encoding.UTF8;
                var web = url + String.Format("/projects/" + projectId + "/rating?public_key={0}&secret_key={1}&type={2}&rate={3}&remarks={4}", publicKey, secretKey, type.GetStringValue(), rate, remarks);

                return client.DownloadString(web);
            }
        }

        public virtual void ShouldEncodeString()
        {
            var monkeyEncoded =
                "00000000000000000000000000000000000000000000000000000000000000064d6f6e6b65790000000000000000000000000000000000000000000000000000";

            //0000000000000000000000000000000000000000000000000000000000000006 is the bytes length
            //4d6f6e6b65790000000000000000000000000000000000000000000000000000 Monkey byte array utf8 encoded
            
            var stringType = new StringType();
            var result = stringType.Encode("Monkey").ToHex();
            Assert.Equal(monkeyEncoded, result);
        }