// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.Serialization;
using System.Text;
using System.Text.RegularExpressions;
namespace System.Json
{
/// <summary>
/// Settings used by the <see cref="InstanceCreator"/> class.
/// </summary>
public static class CreatorSettings
{
static CreatorSettings()
{
MaxArrayLength = 10;
MaxListLength = 10;
MaxStringLength = 100;
CreateOnlyAsciiChars = false;
DontCreateSurrogateChars = false;
CreateDateTimeWithSubMilliseconds = true;
NullValueProbability = 0.01;
AvoidStackOverflowDueToTypeCycles = false;
CreatorSurrogate = null;
}
/// <summary>
/// Gets or sets the maximum length of arrays created by the <see cref="InstanceCreator"/>.
/// </summary>
public static int MaxArrayLength { get; set; }
/// <summary>
/// Gets or sets the maximum length of lists created by the <see cref="InstanceCreator"/>.
/// </summary>
public static int MaxListLength { get; set; }
/// <summary>
/// Gets or sets the maximum length of strings created by the <see cref="InstanceCreator"/>.
/// </summary>
public static int MaxStringLength { get; set; }
/// <summary>
/// Gets or sets a flag indicating whether only ascii chars should be used when creating strings.
/// </summary>
public static bool CreateOnlyAsciiChars { get; set; }
/// <summary>
/// Gets or sets a flag indicating whether chars in the surrogate range can be returned by the
/// <see cref="InstanceCreator"/> when creating char instances.
/// </summary>
public static bool DontCreateSurrogateChars { get; set; }
/// <summary>
/// Gets or sets a flag indicating whether <see cref="DateTime"/> values created by the
/// <see cref="InstanceCreator"/> can have submillisecond precision.
/// </summary>
public static bool CreateDateTimeWithSubMilliseconds { get; set; }
/// <summary>
/// Gets or sets a value (0-1) indicating the probability of the <see cref="InstanceCreator"/>
/// returning a <code>null</code> value when creating instances of class types.
/// </summary>
public static double NullValueProbability { get; set; }
/// <summary>
/// Gets or sets a flag indicating whether the protection against stack overflow
/// for cyclic types is enabled. If this flag is set, whenever a type which has already
/// been created up in the stack is created again, the <see cref="InstanceCreator"/>
/// will return the default value for that type.
/// </summary>
public static bool AvoidStackOverflowDueToTypeCycles { get; set; }
/// <summary>
/// Gets or sets the instance of an <see cref="InstanceCreatorSurrogate"/> which can intercept
/// requests to create instances on the <see cref="InstanceCreator"/>.
/// </summary>
public static InstanceCreatorSurrogate CreatorSurrogate { get; set; }
}
/// <summary>
/// Utility class used to create test instances of primitive types.
/// </summary>
public static class PrimitiveCreator
{
static readonly Regex RelativeIPv6UriRegex = new Regex(@"^\/\/(.+\@)?\[\:\:\d\]");
static Dictionary<Type, MethodInfo> creators;
static PrimitiveCreator()
{
Type primitiveCreatorType = typeof(PrimitiveCreator);
creators = new Dictionary<Type, MethodInfo>();
creators.Add(typeof(bool), primitiveCreatorType.GetMethod("CreateInstanceOfBoolean", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(byte), primitiveCreatorType.GetMethod("CreateInstanceOfByte", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(char), primitiveCreatorType.GetMethod("CreateInstanceOfChar", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(DateTime), primitiveCreatorType.GetMethod("CreateInstanceOfDateTime", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(DateTimeOffset), primitiveCreatorType.GetMethod("CreateInstanceOfDateTimeOffset", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(decimal), primitiveCreatorType.GetMethod("CreateInstanceOfDecimal", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(double), primitiveCreatorType.GetMethod("CreateInstanceOfDouble", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(Guid), primitiveCreatorType.GetMethod("CreateInstanceOfGuid", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(short), primitiveCreatorType.GetMethod("CreateInstanceOfInt16", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(int), primitiveCreatorType.GetMethod("CreateInstanceOfInt32", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(long), primitiveCreatorType.GetMethod("CreateInstanceOfInt64", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(object), primitiveCreatorType.GetMethod("CreateInstanceOfObject", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(sbyte), primitiveCreatorType.GetMethod("CreateInstanceOfSByte", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(float), primitiveCreatorType.GetMethod("CreateInstanceOfSingle", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(string), primitiveCreatorType.GetMethod("CreateInstanceOfString", BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(Random) }, null));
creators.Add(typeof(ushort), primitiveCreatorType.GetMethod("CreateInstanceOfUInt16", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(uint), primitiveCreatorType.GetMethod("CreateInstanceOfUInt32", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(ulong), primitiveCreatorType.GetMethod("CreateInstanceOfUInt64", BindingFlags.Public | BindingFlags.Static));
creators.Add(typeof(Uri), primitiveCreatorType.GetMethod("CreateInstanceOfUri", BindingFlags.Public | BindingFlags.Static));
}
/// <summary>
/// Creates an instance of the <see cref="Boolean"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="Boolean"/> type.</returns>
public static bool CreateInstanceOfBoolean(Random rndGen)
{
return rndGen.Next(2) == 0;
}
/// <summary>
/// Creates an instance of the <see cref="Byte"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="Byte"/> type.</returns>
public static byte CreateInstanceOfByte(Random rndGen)
{
byte[] rndValue = new byte[1];
rndGen.NextBytes(rndValue);
return rndValue[0];
}
/// <summary>
/// Creates an instance of the <see cref="Char"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="Char"/> type.</returns>
public static char CreateInstanceOfChar(Random rndGen)
{
if (CreatorSettings.CreateOnlyAsciiChars)
{
return (char)rndGen.Next(0x20, 0x7F);
}
else if (CreatorSettings.DontCreateSurrogateChars)
{
char c;
do
{
c = (char)rndGen.Next((int)Char.MinValue, (int)Char.MaxValue);
}
while (Char.IsSurrogate(c));
return c;
}
else
{
return (char)rndGen.Next((int)Char.MinValue, (int)Char.MaxValue + 1);
}
}
/// <summary>
/// Creates an instance of the <see cref="DateTime"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="DateTime"/> type.</returns>
public static System.DateTime CreateInstanceOfDateTime(Random rndGen)
{
long temp = CreateInstanceOfInt64(rndGen);
temp = Math.Abs(temp);
DateTime result;
try
{
result = new DateTime(temp % (DateTime.MaxValue.Ticks + 1));
}
catch (ArgumentOutOfRangeException)
{
result = DateTime.Now;
}
int kind = rndGen.Next(3);
switch (kind)
{
case 0:
result = DateTime.SpecifyKind(result, DateTimeKind.Local);
break;
case 1:
result = DateTime.SpecifyKind(result, DateTimeKind.Unspecified);
break;
default:
result = DateTime.SpecifyKind(result, DateTimeKind.Utc);
break;
}
if (!CreatorSettings.CreateDateTimeWithSubMilliseconds)
{
result = new DateTime(
result.Year,
result.Month,
result.Day,
result.Hour,
result.Minute,
result.Second,
result.Millisecond,
result.Kind);
}
return result;
}
/// <summary>
/// Creates an instance of the <see cref="DateTimeOffset"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="DateTimeOffset"/> type.</returns>
public static System.DateTimeOffset CreateInstanceOfDateTimeOffset(Random rndGen)
{
DateTime temp = CreateInstanceOfDateTime(rndGen);
temp = DateTime.SpecifyKind(temp, DateTimeKind.Unspecified);
int offsetMinutes = rndGen.Next(-14 * 60, 14 * 60);
DateTimeOffset result = new DateTimeOffset(temp, TimeSpan.FromMinutes(offsetMinutes));
return result;
}
/// <summary>
/// Creates an instance of the <see cref="Decimal"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="Decimal"/> type.</returns>
public static decimal CreateInstanceOfDecimal(Random rndGen)
{
int low = CreateInstanceOfInt32(rndGen);
int mid = CreateInstanceOfInt32(rndGen);
int high = CreateInstanceOfInt32(rndGen);
bool isNegative = rndGen.Next(2) == 0;
const int MaxDecimalScale = 28;
byte scale = (byte)rndGen.Next(0, MaxDecimalScale + 1);
return new decimal(low, mid, high, isNegative, scale);
}
/// <summary>
/// Creates an instance of the <see cref="Double"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="Double"/> type.</returns>
public static double CreateInstanceOfDouble(Random rndGen)
{
bool negative = rndGen.Next(2) == 0;
int temp = rndGen.Next(40);
double result;
switch (temp)
{
case 0: return Double.NaN;
case 1: return Double.PositiveInfinity;
case 2: return Double.NegativeInfinity;
case 3: return Double.MinValue;
case 4: return Double.MaxValue;
case 5: return Double.Epsilon;
default:
result = (double)(rndGen.NextDouble() * 100000);
if (negative)
{
result = -result;
}
return result;
}
}
/// <summary>
/// Creates an instance of the <see cref="Guid"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="Guid"/> type.</returns>
public static System.Guid CreateInstanceOfGuid(Random rndGen)
{
byte[] temp = new byte[16];
rndGen.NextBytes(temp);
return new Guid(temp);
}
/// <summary>
/// Creates an instance of the <see cref="Int16"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="Int16"/> type.</returns>
public static short CreateInstanceOfInt16(Random rndGen)
{
byte[] rndValue = new byte[2];
rndGen.NextBytes(rndValue);
short result = 0;
for (int i = 0; i < rndValue.Length; i++)
{
result = (short)(result << 8);
result = (short)(result | (short)rndValue[i]);
}
return result;
}
/// <summary>
/// Creates an instance of the <see cref="Int32"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="Int32"/> type.</returns>
public static int CreateInstanceOfInt32(Random rndGen)
{
byte[] rndValue = new byte[4];
rndGen.NextBytes(rndValue);
int result = 0;
for (int i = 0; i < rndValue.Length; i++)
{
result = (int)(result << 8);
result = (int)(result | (int)rndValue[i]);
}
return result;
}
/// <summary>
/// Creates an instance of the <see cref="Int64"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="Int64"/> type.</returns>
public static long CreateInstanceOfInt64(Random rndGen)
{
byte[] rndValue = new byte[8];
rndGen.NextBytes(rndValue);
long result = 0;
for (int i = 0; i < rndValue.Length; i++)
{
result = (long)(result << 8);
result = (long)(result | (long)rndValue[i]);
}
return result;
}
/// <summary>
/// Creates an instance of the <see cref="Object"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="Object"/> type.</returns>
public static object CreateInstanceOfObject(Random rndGen)
{
return (rndGen.Next(5) == 0) ? null : new object();
}
/// <summary>
/// Creates an instance of the <see cref="SByte"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="SByte"/> type.</returns>
[CLSCompliant(false)]
public static sbyte CreateInstanceOfSByte(Random rndGen)
{
byte[] rndValue = new byte[1];
rndGen.NextBytes(rndValue);
sbyte result = (sbyte)rndValue[0];
return result;
}
/// <summary>
/// Creates an instance of the <see cref="Single"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="Single"/> type.</returns>
public static float CreateInstanceOfSingle(Random rndGen)
{
bool negative = rndGen.Next(2) == 0;
int temp = rndGen.Next(40);
float result;
switch (temp)
{
case 0: return Single.NaN;
case 1: return Single.PositiveInfinity;
case 2: return Single.NegativeInfinity;
case 3: return Single.MinValue;
case 4: return Single.MaxValue;
case 5: return Single.Epsilon;
default:
result = (float)(rndGen.NextDouble() * 100000);
if (negative)
{
result = -result;
}
return result;
}
}
/// <summary>
/// Creates an instance of the <see cref="String"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <param name="size">The size of the string to be creted.</param>
/// <param name="charsToUse">The characters to use when creating the string.</param>
/// <returns>An instance of the <see cref="String"/> type.</returns>
public static string CreateRandomString(Random rndGen, int size, string charsToUse)
{
int maxSize = CreatorSettings.MaxStringLength;
// invalid per the XML spec (http://www.w3.org/TR/REC-xml/#charsets), cannot be sent as XML
string invalidXmlChars = "\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u000B\u000C\u000E\u000F\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001A\u001B\u001C\u001D\u001E\u001F\uFFFE\uFFFF";
const int LowSurrogateMin = 0xDC00;
const int LowSurrogateMax = 0xDFFF;
const int HighSurrogateMin = 0xD800;
const int HighSurrogateMax = 0xDBFF;
if (size < 0)
{
double rndNumber = rndGen.NextDouble();
if (rndNumber < CreatorSettings.NullValueProbability)
{
return null; // 1% chance of null value
}
size = (int)Math.Pow(maxSize, rndNumber); // this will create more small strings than large ones
size--;
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < size; i++)
{
char c;
if (charsToUse != null)
{
c = charsToUse[rndGen.Next(charsToUse.Length)];
sb.Append(c);
}
else
{
if (CreatorSettings.CreateOnlyAsciiChars || rndGen.Next(2) == 0)
{
c = (char)rndGen.Next(0x20, 0x7F); // low-ascii chars
sb.Append(c);
}
else
{
do
{
c = (char)rndGen.Next((int)Char.MinValue, (int)Char.MaxValue + 1);
}
while ((LowSurrogateMin <= c && c <= LowSurrogateMax) || (invalidXmlChars.IndexOf(c) >= 0));
sb.Append(c);
if (HighSurrogateMin <= c && c <= HighSurrogateMax)
{
// need to add a low surrogate
c = (char)rndGen.Next(LowSurrogateMin, LowSurrogateMax + 1);
sb.Append(c);
}
}
}
}
return sb.ToString();
}
/// <summary>
/// Creates an instance of the <see cref="String"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="String"/> type.</returns>
public static string CreateInstanceOfString(Random rndGen)
{
return CreateInstanceOfString(rndGen, true);
}
/// <summary>
/// Creates an instance of the <see cref="String"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <param name="allowNull">A flag indicating whether null values can be returned.</param>
/// <returns>An instance of the <see cref="String"/> type.</returns>
public static string CreateInstanceOfString(Random rndGen, bool allowNull)
{
string result;
do
{
result = CreateRandomString(rndGen, -1, null);
}
while (result == null && !allowNull);
return result;
}
/// <summary>
/// Creates an instance of the <see cref="String"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <param name="size">The size of the string to be creted.</param>
/// <param name="charsToUse">The characters to use when creating the string.</param>
/// <returns>An instance of the <see cref="String"/> type.</returns>
public static string CreateInstanceOfString(Random rndGen, int size, string charsToUse)
{
return CreateRandomString(rndGen, size, charsToUse);
}
/// <summary>
/// Creates an instance of the <see cref="UInt16"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="UInt16"/> type.</returns>
[CLSCompliant(false)]
public static ushort CreateInstanceOfUInt16(Random rndGen)
{
byte[] rndValue = new byte[2];
rndGen.NextBytes(rndValue);
ushort result = 0;
for (int i = 0; i < rndValue.Length; i++)
{
result = (ushort)(result << 8);
result = (ushort)(result | (ushort)rndValue[i]);
}
return result;
}
/// <summary>
/// Creates an instance of the <see cref="UInt32"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="UInt32"/> type.</returns>
[CLSCompliant(false)]
public static uint CreateInstanceOfUInt32(Random rndGen)
{
byte[] rndValue = new byte[4];
rndGen.NextBytes(rndValue);
uint result = 0;
for (int i = 0; i < rndValue.Length; i++)
{
result = (uint)(result << 8);
result = (uint)(result | (uint)rndValue[i]);
}
return result;
}
/// <summary>
/// Creates an instance of the <see cref="UInt64"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="UInt64"/> type.</returns>
[CLSCompliant(false)]
public static ulong CreateInstanceOfUInt64(Random rndGen)
{
byte[] rndValue = new byte[8];
rndGen.NextBytes(rndValue);
ulong result = 0;
for (int i = 0; i < rndValue.Length; i++)
{
result = (ulong)(result << 8);
result = (ulong)(result | (ulong)rndValue[i]);
}
return result;
}
/// <summary>
/// Creates an instance of the <see cref="Uri"/> type.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the <see cref="Uri"/> type.</returns>
public static System.Uri CreateInstanceOfUri(Random rndGen)
{
Uri result;
UriKind kind;
try
{
string uriString;
do
{
uriString = UriCreator.CreateUri(rndGen, out kind);
}
while (IsRelativeIPv6Uri(uriString, kind));
result = new Uri(uriString, kind);
}
catch (ArgumentException)
{
result = new Uri("my.schema://userName:password@my.domain/path1/path2?query1=123&query2=%22hello%22");
}
return result;
}
/// <summary>
/// Creates an instance of the a string which represents an <see cref="Uri"/>.
/// </summary>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the a string which represents an <see cref="Uri"/>.</returns>
public static string CreateInstanceOfUriString(Random rndGen)
{
UriKind kind;
return UriCreator.CreateUri(rndGen, out kind);
}
/// <summary>
/// Checks whether this creator can create an instance of the given type.
/// </summary>
/// <param name="type">The type to be created.</param>
/// <returns><code>true</code> if this creator can create an instance of the given type; <code>false</code> otherwise.</returns>
public static bool CanCreateInstanceOf(Type type)
{
return creators.ContainsKey(type);
}
/// <summary>
/// Creates an instance of the given primitive type.
/// </summary>
/// <param name="type">The type to create an instance.</param>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the given type.</returns>
public static object CreatePrimitiveInstance(Type type, Random rndGen)
{
if (creators.ContainsKey(type))
{
return creators[type].Invoke(null, new object[] { rndGen });
}
else
{
throw new ArgumentException("Type " + type.FullName + " not supported");
}
}
private static bool IsRelativeIPv6Uri(string uriString, UriKind kind)
{
return kind == UriKind.Relative && RelativeIPv6UriRegex.Match(uriString).Success;
}
/// <summary>
/// Creates URI instances based on RFC 2396
/// </summary>
internal static class UriCreator
{
static readonly string digit;
static readonly string upalpha;
static readonly string lowalpha;
static readonly string alpha;
static readonly string alphanum;
static readonly string hex;
static readonly string mark;
static readonly string unreserved;
static readonly string reserved;
static UriCreator()
{
digit = "0123456789";
upalpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
lowalpha = upalpha.ToLower();
alpha = upalpha + lowalpha;
alphanum = alpha + digit;
hex = digit + "ABCDEFabcdef";
mark = "-_.!~*'()";
unreserved = alphanum + mark;
reserved = ";/?:@&=+$,";
}
internal static string CreateUri(Random rndGen, out UriKind kind)
{
StringBuilder sb = new StringBuilder();
kind = UriKind.Relative;
if (rndGen.Next(3) > 0)
{
// Add URI scheme
CreateScheme(sb, rndGen);
kind = UriKind.Absolute;
}
if (rndGen.Next(3) > 0)
{
// Add URI host
sb.Append("//");
if (rndGen.Next(10) == 0)
{
CreateUserInfo(sb, rndGen);
}
CreateHost(sb, rndGen);
if (rndGen.Next(2) > 0)
{
sb.Append(':');
sb.Append(rndGen.Next(65536));
}
}
if (rndGen.Next(4) > 0)
{
// Add URI path
for (int i = 0; i < rndGen.Next(1, 4); i++)
{
sb.Append('/');
AddPathSegment(sb, rndGen);
}
}
if (rndGen.Next(3) == 0)
{
// Add URI query string
sb.Append('?');
AddUriC(sb, rndGen);
}
return sb.ToString();
}
private static void CreateScheme(StringBuilder sb, Random rndGen)
{
int size = rndGen.Next(1, 10);
AddChars(sb, rndGen, alpha, 1);
string schemeChars = alpha + digit + "+-.";
AddChars(sb, rndGen, schemeChars, size);
sb.Append(':');
}
private static void CreateIPv4Address(StringBuilder sb, Random rndGen)
{
for (int i = 0; i < 4; i++)
{
if (i > 0)
{
sb.Append('.');
}
sb.Append(rndGen.Next(1000));
}
}
private static void AddIPv6AddressPart(StringBuilder sb, Random rndGen)
{
int size = rndGen.Next(1, 10);
if (size > 4)
{
size = 4;
}
AddChars(sb, rndGen, hex, size);
}
private static void CreateIPv6Address(StringBuilder sb, Random rndGen)
{
sb.Append('[');
int temp = rndGen.Next(6);
int i;
switch (temp)
{
case 0:
sb.Append("::");
break;
case 1:
sb.Append("::1");
break;
case 2:
sb.Append("FF01::101");
break;
case 3:
sb.Append("::1");
break;
case 4:
for (i = 0; i < 3; i++)
{
AddIPv6AddressPart(sb, rndGen);
sb.Append(':');
}
for (i = 0; i < 3; i++)
{
sb.Append(':');
AddIPv6AddressPart(sb, rndGen);
}
break;
default:
for (i = 0; i < 8; i++)
{
if (i > 0)
{
sb.Append(':');
}
AddIPv6AddressPart(sb, rndGen);
}
break;
}
sb.Append(']');
}
private static void AddChars(StringBuilder sb, Random rndGen, string validChars, int size)
{
for (int i = 0; i < size; i++)
{
sb.Append(validChars[rndGen.Next(validChars.Length)]);
}
}
private static void CreateHostName(StringBuilder sb, Random rndGen)
{
int domainLabelCount = rndGen.Next(4);
int size;
for (int i = 0; i < domainLabelCount; i++)
{
AddChars(sb, rndGen, alphanum, 1);
size = rndGen.Next(10) - 1;
if (size > 0)
{
AddChars(sb, rndGen, alphanum + "-", size);
AddChars(sb, rndGen, alphanum, 1);
}
sb.Append('.');
}
AddChars(sb, rndGen, alpha, 1);
size = rndGen.Next(10) - 1;
if (size > 0)
{
AddChars(sb, rndGen, alphanum + "-", size);
AddChars(sb, rndGen, alphanum, 1);
}
}
private static void CreateHost(StringBuilder sb, Random rndGen)
{
int temp = rndGen.Next(3);
switch (temp)
{
case 0:
CreateIPv4Address(sb, rndGen);
break;
case 1:
CreateIPv6Address(sb, rndGen);
break;
case 2:
CreateHostName(sb, rndGen);
break;
}
}
private static void CreateUserInfo(StringBuilder sb, Random rndGen)
{
AddChars(sb, rndGen, alpha, rndGen.Next(1, 10));
if (rndGen.Next(3) > 0)
{
sb.Append(':');
AddChars(sb, rndGen, alpha, rndGen.Next(1, 10));
}
sb.Append('@');
}
private static void AddEscapedChar(StringBuilder sb, Random rndGen)
{
sb.Append('%');
AddChars(sb, rndGen, hex, 2);
}
private static void AddPathSegment(StringBuilder sb, Random rndGen)
{
string pchar = unreserved + ":@&=+$,";
int size = rndGen.Next(1, 10);
for (int i = 0; i < size; i++)
{
if (rndGen.Next(pchar.Length + 1) > 0)
{
AddChars(sb, rndGen, pchar, 1);
}
else
{
AddEscapedChar(sb, rndGen);
}
}
}
private static void AddUriC(StringBuilder sb, Random rndGen)
{
int size = rndGen.Next(20);
string reservedPlusUnreserved = reserved + unreserved;
for (int i = 0; i < size; i++)
{
if (rndGen.Next(5) > 0)
{
AddChars(sb, rndGen, reservedPlusUnreserved, 1);
}
else
{
AddEscapedChar(sb, rndGen);
}
}
}
}
}
/// <summary>
/// Utility class used to create test instances of arbitrary types.
/// </summary>
public static class InstanceCreator
{
private static Stack<Type> typesInCreationStack = new Stack<Type>();
/// <summary>
/// Creates an instance of an array type.
/// </summary>
/// <param name="arrayType">The array type.</param>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the given array type.</returns>
public static object CreateInstanceOfArray(Type arrayType, Random rndGen)
{
Type type = arrayType.GetElementType();
double rndNumber = rndGen.NextDouble();
if (rndNumber < CreatorSettings.NullValueProbability)
{
return null; // 1% chance of null value
}
int size = (int)Math.Pow(CreatorSettings.MaxArrayLength, rndNumber); // this will create more small arrays than large ones
size--;
Array result = Array.CreateInstance(type, size);
for (int i = 0; i < size; i++)
{
result.SetValue(CreateInstanceOf(type, rndGen), i);
}
return result;
}
/// <summary>
/// Creates an instance of a <see cref="List{T}"/>.
/// </summary>
/// <param name="listType">The List<T> type.</param>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the given list type.</returns>
public static object CreateInstanceOfListOfT(Type listType, Random rndGen)
{
Type type = listType.GetGenericArguments()[0];
double rndNumber = rndGen.NextDouble();
if (rndNumber < CreatorSettings.NullValueProbability)
{
return null; // 1% chance of null value
}
int size = (int)Math.Pow(CreatorSettings.MaxListLength, rndNumber); // this will create more small lists than large ones
size--;
object result = Activator.CreateInstance(listType);
MethodInfo addMethod = listType.GetMethod("Add");
for (int i = 0; i < size; i++)
{
addMethod.Invoke(result, new object[] { CreateInstanceOf(type, rndGen) });
}
return result;
}
/// <summary>
/// Creates an instance of a <see cref="LinkedList{T}"/>.
/// </summary>
/// <param name="listType">The LinkedList<T> type.</param>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the given list type.</returns>
public static object CreateInstanceOfLinkedListOfT(Type listType, Random rndGen)
{
Type type = listType.GetGenericArguments()[0];
double rndNumber = rndGen.NextDouble();
if (rndNumber < CreatorSettings.NullValueProbability)
{
return null; // 1% chance of null value
}
int size = (int)Math.Pow(CreatorSettings.MaxListLength, rndNumber); // this will create more small lists than large ones
size--;
object result = Activator.CreateInstance(listType);
MethodInfo addMethod = listType.GetMethod("AddLast", new Type[] { type });
for (int i = 0; i < size; i++)
{
addMethod.Invoke(result, new object[] { CreateInstanceOf(type, rndGen) });
}
return result;
}
/// <summary>
/// Creates an instance of a <see cref="IEnumerable{T}"/>.
/// </summary>
/// <param name="enumerableOfTType">The IEnumerable<T> type.</param>
/// <param name="enumeredType">The type to be enumerated.</param>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the given enumerable type.</returns>
public static object CreateInstanceOfIEnumerableOfT(Type enumerableOfTType, Type enumeredType, Random rndGen)
{
double rndNumber = rndGen.NextDouble();
if (!enumerableOfTType.IsValueType && rndNumber < CreatorSettings.NullValueProbability)
{
return null; // 1% chance of null value
}
int size = (int)Math.Pow(CreatorSettings.MaxListLength, rndNumber); // this will create more small lists than large ones
size--;
object result = Activator.CreateInstance(enumerableOfTType);
MethodInfo addMethod = enumerableOfTType.GetMethod("Add", new Type[] { enumeredType });
if (addMethod == null)
{
throw new ArgumentException("Cannot create an instance of an IEnumerable<T> type which does not have a public Add method");
}
for (int i = 0; i < size; i++)
{
addMethod.Invoke(result, new object[] { CreateInstanceOf(enumeredType, rndGen) });
}
return result;
}
/// <summary>
/// Creates an instance of a <see cref="Nullable{T}"/>.
/// </summary>
/// <param name="nullableOfTType">The Nullable<T> type.</param>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the given nullable type.</returns>
public static object CreateInstanceOfNullableOfT(Type nullableOfTType, Random rndGen)
{
if (rndGen.Next(5) == 0)
{
return null;
}
Type type = nullableOfTType.GetGenericArguments()[0];
return CreateInstanceOf(type, rndGen);
}
/// <summary>
/// Creates an instance of an enum type..
/// </summary>
/// <param name="enumType">The enum type.</param>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the given enum type.</returns>
public static object CreateInstanceOfEnum(Type enumType, Random rndGen)
{
bool hasFlags = enumType.GetCustomAttributes(typeof(FlagsAttribute), true).Length > 0;
Array possibleValues = Enum.GetValues(enumType);
if (possibleValues.Length == 0)
{
return 0;
}
if (!hasFlags)
{
return possibleValues.GetValue(rndGen.Next(possibleValues.Length));
}
else
{
Type underlyingType = Enum.GetUnderlyingType(enumType);
string strResult;
if (underlyingType.FullName == typeof(ulong).FullName)
{
ulong result = 0;
if (rndGen.Next(10) > 0)
{
// 10% chance of value zero
foreach (object value in possibleValues)
{
if (rndGen.Next(2) == 0)
{
result |= ((IConvertible)value).ToUInt64(null);
}
}
}
strResult = result.ToString();
}
else
{
long result = 0;
if (rndGen.Next(10) > 0)
{
// 10% chance of value zero
foreach (object value in possibleValues)
{
if (rndGen.Next(2) == 0)
{
result |= ((IConvertible)value).ToInt64(null);
}
}
}
strResult = result.ToString();
}
return Enum.Parse(enumType, strResult, true);
}
}
/// <summary>
/// Creates an instance of a <see cref="Dictionary{K,V}"/>.
/// </summary>
/// <param name="dictionaryType">The Dictionary<K,V> type.</param>
/// <param name="rndGen">A <see cref="Random"/> used to create the instance.</param>
/// <returns>An instance of the given dictionary type.</returns>
public static object CreateInstanceOfDictionaryOfKAndV(Type dictionaryType, Random rndGen)
{
Type[] genericArgs = dictionaryType.GetGenericArguments();
Type typeK = genericArgs[0];
Type typeV = genericArgs[1];
double rndNumber = rndGen.NextDouble();
if (rndNumber < CreatorSettings.NullValueProbability)
{
return null; // 1% chance of null value
}
int size = (int)Math.Pow(CreatorSettings.MaxListLength, rndNumber); // this will create more small dictionaries than large ones
size--;
object result = Activator.CreateInstance(dictionaryType);
MethodInfo addMethod = dictionaryType.GetMethod("Add");
MethodInfo containsKeyMethod = dictionaryType.GetMethod("ContainsKey");
for (int i = 0; i < size; i++)
{
object newKey;
do
{
newKey = CreateInstanceOf(typeK, rndGen);
}
while (newKey == null);
bool containsKey = (bool)containsKeyMethod.Invoke(result, new object[] { newKey });
if (!containsKey)
{
object newValue = CreateInstanceOf(typeV, rndGen);
addMethod.Invoke(result, new object[] { newKey, newValue });
}
}
return result;
}
/// <summary>
/// Creates an instance of the given type.
/// </summary>
/// <typeparam name="T">The type to create an instance from.</typeparam>
/// <param name="rndGen">A random generator used to populate the instance.</param>
/// <returns>An instance of the given type.</returns>
public static T CreateInstanceOf<T>(Random rndGen)
{
return (T)InstanceCreator.CreateInstanceOf(typeof(T), rndGen);
}
/// <summary>
/// Creates an instance of the given type.
/// </summary>
/// <param name="type">The type to create an instance from.</param>
/// <param name="rndGen">A random generator used to populate the instance.</param>
/// <param name="allowNulls">A flag indicating whether null values can be returned by this method.</param>
/// <returns>An instance of the given type.</returns>
public static object CreateInstanceOf(Type type, Random rndGen, bool allowNulls)
{
double currentNullProbability = CreatorSettings.NullValueProbability;
if (!allowNulls)
{
CreatorSettings.NullValueProbability = 0;
}
object result = CreateInstanceOf(type, rndGen);
if (!allowNulls)
{
CreatorSettings.NullValueProbability = currentNullProbability;
}
return result;
}
/// <summary>
/// Creates an instance of the given type.
/// </summary>
/// <param name="type">The type to create an instance from.</param>
/// <param name="rndGen">A random generator used to populate the instance.</param>
/// <returns>An instance of the given type.</returns>
public static object CreateInstanceOf(Type type, Random rndGen)
{
if (CreatorSettings.CreatorSurrogate != null)
{
if (CreatorSettings.CreatorSurrogate.CanCreateInstanceOf(type))
{
return CreatorSettings.CreatorSurrogate.CreateInstanceOf(type, rndGen);
}
}
ConstructorInfo randomConstructor = type.GetConstructor(new Type[] { typeof(Random) });
if (randomConstructor != null)
{
// it's possible that a class with a Type.GetConstructor will return a constructor
// which takes a System.Object; we only want to use if it really takes a Random argument.
ParameterInfo[] ctorParameters = randomConstructor.GetParameters();
if (ctorParameters.Length == 1 && ctorParameters[0].ParameterType == typeof(Random))
{
return randomConstructor.Invoke(new object[] { rndGen });
}
}
// Allow for a static factory method (called 'CreateInstance' to allow for inheritance scenarios
MethodInfo randomFactoryMethod = type.GetMethod("CreateInstance", BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(Random) }, null);
if (randomFactoryMethod != null)
{
ParameterInfo[] methodParameters = randomFactoryMethod.GetParameters();
if (methodParameters.Length == 1 && methodParameters[0].ParameterType == typeof(Random))
{
return randomFactoryMethod.Invoke(null, new object[] { rndGen });
}
}
object result = null;
Type genericElementType = null;
if (CreatorSettings.AvoidStackOverflowDueToTypeCycles)
{
if (typesInCreationStack.Contains(type))
{
if (type.IsValueType)
{
return Activator.CreateInstance(type);
}
else
{
return null;
}
}
typesInCreationStack.Push(type);
}
if (PrimitiveCreator.CanCreateInstanceOf(type))
{
result = PrimitiveCreator.CreatePrimitiveInstance(type, rndGen);
}
else if (type.IsEnum)
{
result = CreateInstanceOfEnum(type, rndGen);
}
else if (type.IsArray)
{
result = CreateInstanceOfArray(type, rndGen);
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
{
result = CreateInstanceOfNullableOfT(type, rndGen);
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>))
{
result = CreateInstanceOfListOfT(type, rndGen);
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(LinkedList<>))
{
result = CreateInstanceOfLinkedListOfT(type, rndGen);
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<,>))
{
result = CreateInstanceOfDictionaryOfKAndV(type, rndGen);
}
else if (ContainsAttribute(type, typeof(DataContractAttribute)))
{
result = ClassInstanceCreator.DataContractCreator.CreateInstanceOf(type, rndGen);
}
else if (IsIEnumerableOfT(type, out genericElementType))
{
result = CreateInstanceOfIEnumerableOfT(type, genericElementType, rndGen);
}
else if (type.IsPublic || type.IsNestedPublic)
{
result = ClassInstanceCreator.POCOCreator.CreateInstanceOf(type, rndGen);
}
else
{
result = Activator.CreateInstance(type);
}
if (CreatorSettings.AvoidStackOverflowDueToTypeCycles)
{
typesInCreationStack.Pop();
}
return result;
}
internal static bool ContainsAttribute(MemberInfo member, Type attributeType)
{
object[] attributes = member.GetCustomAttributes(attributeType, false);
return attributes != null && attributes.Length > 0;
}
static bool IsIEnumerableOfT(Type type, out Type genericArgumentType)
{
genericArgumentType = null;
foreach (Type interfaceType in type.GetInterfaces())
{
if (interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
{
genericArgumentType = interfaceType.GetGenericArguments()[0];
return true;
}
}
return false;
}
}
/// <summary>
/// Helper class used to create test instances.
/// </summary>
public class ClassInstanceCreator
{
static ClassInstanceCreator dataContractCreatorWithNonPublicMembers;
static ClassInstanceCreator dataContractCreator;
static ClassInstanceCreator pocoCreator;
bool includeNonPublicMembers;
GetMemberNameDelegate getMemberNameDelegate;
ShouldBeIncludedDelegate shouldBeIncludedDelegate;
private ClassInstanceCreator(GetMemberNameDelegate getMemberNameDelegate, ShouldBeIncludedDelegate shouldBeIncludedDelegate, bool includeNonPublicMembers)
: this(getMemberNameDelegate, shouldBeIncludedDelegate)
{
this.includeNonPublicMembers = includeNonPublicMembers;
}
private ClassInstanceCreator(GetMemberNameDelegate getMemberNameDelegate, ShouldBeIncludedDelegate shouldBeIncludedDelegate)
{
this.getMemberNameDelegate = getMemberNameDelegate;
this.shouldBeIncludedDelegate = shouldBeIncludedDelegate;
}
delegate string GetMemberNameDelegate(MemberInfo member);
delegate bool ShouldBeIncludedDelegate(MemberInfo member);
/// <summary>
/// Gets an instance of a creator which knows how to create instance of types
/// decorated with the <see cref="DataContractAttribute"/>.
/// </summary>
public static ClassInstanceCreator DataContractCreator
{
get
{
if (dataContractCreator == null)
{
dataContractCreator = new ClassInstanceCreator(GetDataMemberName, IncludeDataMembersOnly);
}
return dataContractCreator;
}
}
/// <summary>
/// Gets an instance of a creator which knows how to create instance of types
/// which only sets members decorated with the <see cref="DataMemberAttribute"/>.
/// </summary>
public static ClassInstanceCreator DataContractCreatorWithNonPublicMembers
{
get
{
if (dataContractCreatorWithNonPublicMembers == null)
{
dataContractCreatorWithNonPublicMembers = new ClassInstanceCreator(GetDataMemberName, IncludeDataMembersOnly, true);
}
return dataContractCreatorWithNonPublicMembers;
}
}
/// <summary>
/// Gets an instance of a creator which knows how to create instances of POCO
/// types (public types, not decorated with the <see cref="DataContractAttribute"/> and
/// which have a parameterless public constructor).
/// </summary>
public static ClassInstanceCreator POCOCreator
{
get
{
if (pocoCreator == null)
{
pocoCreator = new ClassInstanceCreator(
delegate(MemberInfo member) { return member.Name; },
DoNotIncludeExcludedMembers);
}
return pocoCreator;
}
}
/// <summary>
/// Creates an instance of the given type.
/// </summary>
/// <param name="type">The type to create an instance from.</param>
/// <param name="rndGen">A random generator used to populate the instance.</param>
/// <returns>An instance of the given type.</returns>
public object CreateInstanceOf(Type type, Random rndGen)
{
object result = null;
if (rndGen.NextDouble() < CreatorSettings.NullValueProbability && !type.IsValueType)
{
// 1% chance of null object, if it is not a struct
return null;
}
ConstructorInfo randomConstructor = type.GetConstructor(new Type[] { typeof(Random) });
if (randomConstructor != null && randomConstructor.GetParameters()[0].ParameterType == typeof(Random))
{
result = randomConstructor.Invoke(new object[] { rndGen });
}
else
{
ConstructorInfo defaultConstructor = type.GetConstructor(new Type[0]);
if (defaultConstructor != null || type.IsValueType)
{
result = Activator.CreateInstance(type);
this.SetFieldsAndProperties(type, result, rndGen);
}
else
{
throw new ArgumentException("Don't know how to create an instance of " + type.FullName);
}
}
return result;
}
private static string GetDataMemberName(MemberInfo member)
{
DataMemberAttribute[] dataMemberAttr = (DataMemberAttribute[])member.GetCustomAttributes(typeof(DataMemberAttribute), false);
if (dataMemberAttr == null || dataMemberAttr.Length == 0 || dataMemberAttr[0].Name == null)
{
return member.Name;
}
else
{
return dataMemberAttr[0].Name;
}
}
private static bool ContainsAttribute(MemberInfo member, string attributeName)
{
object[] customAttributes = member.GetCustomAttributes(false);
foreach (object attribute in customAttributes)
{
if (attribute != null && attribute.GetType().Name == attributeName)
{
return true;
}
}
return false;
}
private static bool IncludeDataMembersOnly(MemberInfo member)
{
return ContainsAttribute(member, "DataMemberAttribute");
}
private static bool DoNotIncludeExcludedMembers(MemberInfo member)
{
return !ContainsAttribute(member, "IgnoreDataMemberAttribute");
}
int CompareDataMembers(MemberInfo member1, MemberInfo member2)
{
return this.getMemberNameDelegate(member1).CompareTo(this.getMemberNameDelegate(member2));
}
private void SetFieldsAndProperties(Type type, object obj, Random rndGen)
{
List<MemberInfo> members = new List<MemberInfo>();
BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
if (this.includeNonPublicMembers)
{
bindingFlags |= BindingFlags.NonPublic;
}
FieldInfo[] fields = type.GetFields(bindingFlags);
PropertyInfo[] properties = type.GetProperties(bindingFlags);
foreach (FieldInfo field in fields)
{
if (this.shouldBeIncludedDelegate(field))
{
members.Add(field);
}
}
foreach (PropertyInfo prop in properties)
{
if (this.shouldBeIncludedDelegate(prop))
{
members.Add(prop);
}
}
members.Sort(new Comparison<MemberInfo>(this.CompareDataMembers));
foreach (MemberInfo member in members)
{
if (member is FieldInfo)
{
object fieldValue = InstanceCreator.CreateInstanceOf(((FieldInfo)member).FieldType, rndGen);
((FieldInfo)member).SetValue(obj, fieldValue);
}
else
{
PropertyInfo propInfo = (PropertyInfo)member;
if (propInfo.CanWrite)
{
object propertyValue = InstanceCreator.CreateInstanceOf(propInfo.PropertyType, rndGen);
propInfo.SetValue(obj, propertyValue, null);
}
else
{
if (!this.TrySettingMembersOfGetOnlyCollection(rndGen, propInfo, obj))
{
throw new ArgumentException("Cannot set property " + propInfo.Name + " of type " + type.FullName);
}
}
}
}
}
private bool TrySettingMembersOfGetOnlyCollection(Random rndGen, PropertyInfo propInfo, object obj)
{
Type propType = propInfo.PropertyType;
object propValue = propInfo.GetValue(obj, null);
if (propValue == null)
{
// need something to set the value to
return false;
}
if (propType.IsArray)
{
Array propArray = (Array)propValue;
Type arrayType = propType.GetElementType();
for (int i = 0; i < propArray.Length; i++)
{
object elementValue = InstanceCreator.CreateInstanceOf(arrayType, rndGen);
propArray.SetValue(elementValue, i);
}
return true;
}
else if (propType.IsGenericType && propType.GetGenericTypeDefinition() == typeof(List<>))
{
Type listType = propType.GetGenericArguments()[0];
MethodInfo addMethod = propType.GetMethod("Add", new Type[] { listType });
double rndNumber = rndGen.NextDouble();
int size = (int)Math.Pow(CreatorSettings.MaxListLength, rndNumber); // this will create more small lists than large ones
size--;
for (int i = 0; i < size; i++)
{
object listValue = InstanceCreator.CreateInstanceOf(listType, rndGen);
addMethod.Invoke(propValue, new object[] { listValue });
}
return true;
}
return false;
}
}
/// <summary>
/// Enables tests to create specific instances of certain types.
/// </summary>
public abstract class InstanceCreatorSurrogate
{
/// <summary>
/// Checks whether this surrogate can create instances of a given type.
/// </summary>
/// <param name="type">The type which needs to be created.</param>
/// <returns>A true value if this surrogate can create the given type; a
/// false value otherwise.</returns>
public abstract bool CanCreateInstanceOf(Type type);
/// <summary>
/// Creates an instance of the given type.
/// </summary>
/// <param name="type">The type to create an instance for.</param>
/// <param name="rndGen">A Random generator to assist in creating the instance.</param>
/// <returns>An instance of the given type.</returns>
public abstract object CreateInstanceOf(Type type, Random rndGen);
}
}