public void ListTest()
{
List <int> list = faker.Create <List <int> >();
Assert.IsNotNull(list);
Assert.AreNotEqual(list, default);
}
static void Main(string[] args)
{
FakerConfig config = new FakerConfig();
config.Add <TestClassWithProperties, byte, ByteNotRandomGenerator>(exspression => exspression.CustomGeneratorCheckProperty1);
config.Add <TestClassWithConstructor, byte, ByteNotRandomGenerator>(exspression => exspression.CustomGeneratorCheckProperty2);
Faker.Faker faker = new Faker.Faker(config);
ConsoleJsonSerializer.Serialize(faker.Create <TestClassWithProperties>());
Console.WriteLine();
ConsoleJsonSerializer.Serialize(faker.Create <TestClassWithConstructor>());
Console.ReadKey();
}
public object generateValue(Type type)
{
if (DTOList.Contains(type))
{
if (_cycleControlList.Contains(type))
{
_cycleControlList.Remove(type);
return(null);
}
List <Type> tmpCycleControlList = new List <Type>();
tmpCycleControlList.AddRange(_cycleControlList);
object tmpObject = faker.Create(type);
_cycleControlList = tmpCycleControlList;
return(tmpObject);
}
if (_generators.ContainsKey(type.Name))
{
return(_generators[type.Name].generate());
}
if (_collectionGenerators.ContainsKey(type.Name))
{
return(_collectionGenerators[type.Name].generate(type.GenericTypeArguments[0]));
}
return(type.IsValueType ? Activator.CreateInstance(type) : null);
}
static void Main(string[] args)
{
Faker faker = new Faker();
ClassDTO_A test = faker.Create <ClassDTO_A>();
Console.WriteLine(JsonConvert.SerializeObject(test, Formatting.Indented));
}
static void Main(string[] args)
{
Faker.Faker faker = new Faker.Faker();
Foo foo = faker.Create <Foo>();
Console.WriteLine("text1=" + foo.text);
Console.WriteLine("number1=" + foo.number);
Console.WriteLine("date1=" + foo.date.Date);
Console.WriteLine("foo1.bar.floatingPoint=" + foo.bar.floatingPoint);
Console.WriteLine("foo1.data[0].floatingPoint=" + foo.data[0].floatingPoint);
Console.WriteLine();
Foo foo2 = faker.Create <Foo>();
Console.WriteLine("text2=" + foo2.text);
Console.WriteLine("number2=" + foo2.number);
Console.WriteLine("date2=" + foo2.date);
Console.WriteLine("foo2.bar.floatingPoint=" + foo2.bar.floatingPoint);
Console.WriteLine("foo2.data[0].floatingPoint=" + foo2.data[0].floatingPoint);
}
public void Config()
{
FakerConfig fakerConfig = new FakerConfig();
fakerConfig.Add <Bar, int, BarIisGenerator>(Bar => Bar.isS);
Faker.Faker configFaker = new Faker.Faker(fakerConfig);
Bar bar = (Bar)configFaker.Create <Bar>();
Assert.AreEqual(bar.isS, 123);
}
static void Main(string[] args)
{
var faker = new Faker();
Foo foo = faker.Create <Foo>();
Console.WriteLine("{0} {1} {2} {3} {4}", foo.x, foo.y, foo.z.x, foo.z.foo, foo.Num);
// foreach (var bar in foo.z)
// {
// Console.WriteLine("{0} {1}", bar.x, bar.y);
// }
}
public override List <T> Generate()
{
int size = new Random().Next(0, 21);
List <T> list = new List <T>();
for (int i = 1; i < size; i++)
{
list.Add(Faker.Create <T>());
}
return(list);
}
public void CustomGenerationTest()
{
IFakerConfig config = new FakerConfig();
config.Add <CustomClassWithProperty, byte, ByteNotRandomGenerator>(cl => cl.ByteValue1);
config.Add <CustomClassWithConstructor, byte, ByteNotRandomGenerator>(cl => cl.ByteValue2);
Assert.ThrowsException <ArgumentException>(() => config.Add <CustomClassWithProperty, string, ByteNotRandomGenerator>(err => err.SomeString));
faker = new Faker.Faker(config);
CustomClassWithProperty propertyClass = faker.Create <CustomClassWithProperty>();
Assert.AreEqual(ByteNotRandomGenerator.DefaultGeneratedValue, propertyClass.ByteValue1);
Assert.AreNotEqual(ByteNotRandomGenerator.DefaultGeneratedValue, propertyClass._byteValue);
CustomClassWithConstructor constructorClass = faker.Create <CustomClassWithConstructor>();
Assert.AreNotEqual(ByteNotRandomGenerator.DefaultGeneratedValue, constructorClass.ByteValue2);
Assert.AreNotEqual(ByteNotRandomGenerator.DefaultGeneratedValue, constructorClass.ByteValue1);
Assert.AreNotEqual(ByteNotRandomGenerator.DefaultGeneratedValue, constructorClass._byteValue);
}
static void Main(string[] args)
{
var faker = new Faker();
Foo foo = faker.Create <Foo>();
PrivateClass clas = faker.Create <PrivateClass>();
Console.WriteLine(foo.Age);
Console.WriteLine(foo.Name);
Console.WriteLine(foo.IsTrue);
Console.WriteLine(foo.Bar.Str);
Console.WriteLine(foo.Bar.NewDouble);
string intArrToString = "Bar IntList = ";
foreach (int i in foo.Bar.IntList)
{
intArrToString += i + "; ";
}
Console.WriteLine(intArrToString);
Console.WriteLine(foo.Bar.DateTime);
Console.ReadLine();
}
static void Main(string[] args)
{
DllLoader dllLoader = new DllLoader();
IPlugin plugin = dllLoader.Load(@"D:\учеба\5 семестр\СПП\Faker\RandomPlugin\bin\Debug\RandomPlugin.dll");
ConcurrentDictionary <Type, IGenerator> dictionary = plugin.GetGenerators();
Faker.Faker faker = new Faker.Faker(plugin.GetGenerators());
Sor t = faker.Create <Sor>();
Console.WriteLine(t.ToString());
Console.ReadKey();
}
public object Generate()
{
var type = typeof(T);
var arrLength = Random.Next(1, 30);
var result = Array.CreateInstance(type, arrLength);
var faker = new Faker();
for (var i = 0; i < arrLength; i++)
{
var item = (T)faker.Create <T>();
result.SetValue(item, i);
}
return(result);
}
public object Generate()
{
var list = new List <T>();
var size = Random.Next(1, 30);
var faker = new Faker();
for (var i = 0; i < size; i++)
{
var item = (T)faker.Create <T>();
list.Add(item);
}
return(list);
}
public object Generate(Type type)
{
var listType = typeof(List <>);
var listGenericType = listType.MakeGenericType(type);
var list = Activator.CreateInstance(listGenericType) as IList;
var size = _random.Next(1, 30);
var faker = new Faker();
for (int i = 0; i < size; i++)
{
var item = faker.Create(type);
list.Add(item);
}
return(list);
}
static void Main(string[] args)
{
var faker = new Faker();
Foo foo = faker.Create <Foo>();
Console.WriteLine($"i: {foo.i}, s: {foo.s}, dt: {foo.dt}, bar.i: {foo.bar.i}, bar.foo: {foo.bar.foo}");
Console.WriteLine("bar.list:");
foreach (var item in foo.bar.list)
{
Console.Write($"{item}, ");
}
Console.ReadKey();
}
static void Main(string[] args)
{
var faker = new Faker();
Foo foo = faker.Create <Foo>();
Console.WriteLine($"floatValue: {foo.floatValue}, string: {foo.str}, dt: {foo.dt}, bar.integerValue: {foo.bar.integerValue}, bar.foo: {foo.bar.foo}");
Console.WriteLine("bar.list:");
foreach (var item in foo.bar.stringList)
{
Console.Write($"{item}\n");
}
Console.ReadKey();
}
public object Generate(Type type)
{
IList listinstance = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(type));
int listsize = rnd.Next(1, 21);
for (int i = 0; i < listsize; i++)
{
listinstance.Add(CurrentFaker.Create(type));
}
return(listinstance);
/*
* int listsize = rnd.Next(1, 21);
* List<T> listinstance = new List<T>();
* for(int i = 0; i < listsize; i++)
* {
* listinstance.Add(CurrentFaker.Create<T>());
* }
* return listinstance;
* /*
* IList listinstance = (IList)Activator.CreateInstance(typeof(List<>).MakeGenericType(listtype));
* int listsize = rnd.Next(1, 21);
* for(int i = 0; i < listsize; i++)
* {
* listinstance.Add(CurrentFaker.Create<listtype>());
* /*
* IGenerator value;
* AvailableGenerators.TryGetValue(listtype, out value);
* if (value != null)
* {
* listinstance.Add(value.Generate());
* }
* else
* {
* listinstance.Add(null);
* }
*
* }
* return listinstance;
*/
}
public void Start()
{
faker = new Faker.Faker();
foo = faker.Create <Foo>();
exampleClass = faker.Create <PrivateClass>();
}
public void NullableFieldsTest()
{
NullableFieldsClassNoConstructor noConstructorObject = faker.Create <NullableFieldsClassNoConstructor>();
Assert.AreNotEqual(null, noConstructorObject.dateTimeField);
Assert.AreNotEqual(null, noConstructorObject.listField);
Assert.AreNotEqual(null, noConstructorObject.objectField);
NullableFieldsClassWithConstructor constructorObject = faker.Create <NullableFieldsClassWithConstructor>();
Assert.AreNotEqual(null, constructorObject.listField);
Assert.AreEqual(default(DateTime), constructorObject.dateTimeField);
Assert.AreEqual(default(object), constructorObject.objectField);
}
static void Main(string[] args)
{
Faker faker = new Faker();
int t = faker.Create <int>();
bool b = faker.Create <bool>();
byte c = faker.Create <byte>();
float f = faker.Create <float>();
DateTime dt = faker.Create <DateTime>();
char ch = faker.Create <char>();
double d = faker.Create <double>();
long lng = faker.Create <long>();
string str = faker.Create <string>();
List <int> listtest = faker.Create <List <int> >();
Console.WriteLine("{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}", t, b, c, f, dt, ch, d, lng, str);
Console.WriteLine();
for (int i = 0; i < listtest.Count(); i++)
{
Console.WriteLine("{0}", listtest[i]);
}
Enum en = faker.Create <Enum>();
D classtest = faker.Create <D>();
Foo testrecursion = faker.Create <Foo>();
A classwithnoconstructor = faker.Create <A>();
B recursive = faker.Create <B>();
PrivateConstructor pc = faker.Create <PrivateConstructor>();
TestProperties tp = faker.Create <TestProperties>();
List <TestClass> testclass = faker.Create <List <TestClass> >();
short sh = faker.Create <short>();
Console.ReadLine();
}