public void Test_FromXml()
{
// get xml string
string xmlString = WriteHelper.CreateXmlText(mData);
var xml = new XmlDocument();
xml.LoadXml(xmlString);
var objBuilder = new ObjectBuilder();
objBuilder.RegisterAssembly(this.GetType().Assembly);
// back to object
object obj = objBuilder.CreateObjectFromXml(xml.DocumentElement);
Assert.AreEqual(obj != null, true);
var a = obj as A;
Assert.AreEqual(a != null, true);
Assert.AreEqual(a.ID, 999);
Assert.AreEqual(a.Data != null, true);
Assert.AreEqual(a.Data.Amount, 123.45);
Assert.AreEqual(a.Enabled, true);
Assert.AreEqual(a.MultiValues.Length, 3);
Assert.AreEqual(a.MultiValues[0], "aaa");
}
public void ResolvesChildren()
{
var testObject = new TestObject() { Id = 1, Children = new List<TestObject>() };
var child = new TestObject();
var mChildState = new Mock<IObjectState>(MockBehavior.Strict);
var builder = new ObjectBuilder<TestObject>(testObject);
var t1 = builder
.Dependent(mChildState.Object)
.Build(state => new ObjectBuilder<TestObject>(child));
var t2 = t1.Resolve(
(resolver, target, dependent) => target.Add(dependent)
);
Assert.That(t1, Is.EqualTo(t2));
Assert.That(builder.DependentObjects.First(), Is.EqualTo(t2));
var context = (IBuilderContext) t2;
var resolved = context.Build(null);
Assert.That(resolved, Is.EqualTo(child));
var r = builder.Materialise();
Assert.That(r, Is.EqualTo(testObject));
Assert.That(r.Children, Is.Not.Null);
Assert.That(r.Children.First(), Is.EqualTo(child));
}
public static ObjectBuilder<SolarSystem> Build(StarCluster starCluster, SolarSystemState state)
{
var solarSystem = new SolarSystem
{
Id = state.ObjectId,
Name = state.Name,
Position = new Position(starCluster, state.LocalCoordinates),
};
var builder = new ObjectBuilder<SolarSystem>(solarSystem)
.Resolve((target, resolver) => BuildOrbits(state, target));
builder
.Dependents(state.Ships)
.Build(Echo.Ships.Ship.Builder.Build)
.Resolve((resolver, target, dependent) => target.Ships.Add(dependent));
builder
.Dependents(state.JumpGates)
.Build(Echo.JumpGates.JumpGate.Builder.Build)
.Resolve((resolver, target, dependent) => target.JumpGates.Add(dependent));
builder
.Dependents(state.Satellites)
.Build((target, dependent) => CelestialObject.Builder.For(dependent).Build(solarSystem))
.Resolve((resolver, target, dependent) => target.Satellites.Add(dependent));
builder
.Dependents(state.Structures)
.Build((target, dependent) => Structure.Builder.For(dependent).Build(solarSystem))
.Resolve((resolver, target, dependent) => target.Structures.Add(dependent));
return builder;
}
public void LoadFeed(TaskScheduler uiContext) {
ObjectBuilder builder = new ObjectBuilder ();
Task<IList<RSSItem>> loadFeedTask = builder.FillFeedAsync (ItemFeed, GetBuilderParams(), CancellationToken.None);
loadFeedTask.Start ();
loadFeedTask.ContinueWith (x => FeedLoaded(/*x.Result*/), uiContext);
}
public void SetUp()
{
mocks = new MockRepository();
reflectionUtil = mocks.DynamicMock<IReflectionUtil>();
builder = new ObjectBuilder<MyClass>(reflectionUtil);
myClassWithConstructorBuilder = new ObjectBuilder<MyClassWithConstructor>(reflectionUtil);
myClassWithOptionalConstructorBuilder = new ObjectBuilder<MyClassWithOptionalConstructor>(reflectionUtil);
}
public void LoadMemberArticles(TaskScheduler uiContext) {
memberArticles = new CodeProjectMemberArticles();
Dictionary<String, String> param = new Dictionary<string, string> ();
param.Add ("Id", MemberId.ToString());
ObjectBuilder objectBuilder = new ObjectBuilder ();
Task<IList<CodeProjectMemberArticle>> loadArticleTask = objectBuilder.FillListAsync (memberArticles, param, () => new CodeProjectMemberArticle(), CancellationToken.None);
loadArticleTask.Start ();
loadArticleTask.ContinueWith (x => ArticlesLoaded (), uiContext);
}
public void Resolves()
{
var testObject = new TestObject() { Id = 1, Children = new List<TestObject>() };
var mChildObject = new Mock<IObject>(MockBehavior.Strict);
mChildObject.SetupGet(o => o.Id).Returns(2);
var mChildState = new Mock<IObjectState>(MockBehavior.Strict);
var builder = new ObjectBuilder<IObject>(testObject);
builder.Dependents(new[] { mChildState.Object }).Build(state => new ObjectBuilder<IObject>(mChildObject.Object));
var r = builder.Materialise();
Assert.That(r, Is.EqualTo(testObject));
}
public void LoadMember(TaskScheduler uiContext) {
Dictionary<String, String> param = new Dictionary<string, string> ();
param.Add ("Id", MemberId.ToString());
Member = new CodeProjectMember ();
Member.Id = MemberId;
ObjectBuilder objectBuilder = new ObjectBuilder ();
Task<object> fillMemberTask = objectBuilder.FillAsync (Member, param, CancellationToken.None);
fillMemberTask.Start ();
fillMemberTask
.ContinueWith (x => LoadGravatar ())
.ContinueWith (x => MemberLoaded (), uiContext);
}
public void Dependents()
{
var mObject = new Mock<IObject>(MockBehavior.Strict);
mObject.SetupGet(o => o.Id).Returns(1);
var mChildObject = new Mock<IObject>(MockBehavior.Strict);
mChildObject.SetupGet(o => o.Id).Returns(2);
var mChildState = new Mock<IObjectState>(MockBehavior.Strict);
var builder = new ObjectBuilder<IObject>(mObject.Object);
builder.Dependents(new[] { mChildState.Object }).Build(state => new ObjectBuilder<IObject>(mChildObject.Object));
Assert.That(builder.DependentObjects, Is.Not.Empty);
Assert.That(builder.DependentObjects, Has.Exactly(1).Matches<IBuilderContext>(x => x.Target.Id == 2));
}
public static ObjectBuilder<Corporation> Build(CorporationState state)
{
var corporation = new Corporation
{
Id = state.ObjectId,
Name = state.Name,
};
var builder = new ObjectBuilder<Corporation>(corporation);
builder
.Dependents(state.Employees)
.Build(Agent.Builder.Build)
.Resolve((resolver, target, agent) => AddEmployee(target, agent));
return builder;
}
public static ObjectBuilder<Item> Build(ItemState state, ILocation location = null, Corporation owner = null)
{
var objRef = state.Type.ToObjectReference(state.Code);
var item = new Item
{
Id = state.ObjectId,
Quantity = state.Quantity,
Location = location,
Owner = owner,
};
var builder = new ObjectBuilder<Item>(item);
builder
.Resolve((resolver, target) => item.ItemInfo = resolver.Get<ItemInfo>(objRef));
return builder;
}
public static ObjectBuilder<StarCluster> Build(Universe universe, StarClusterState state)
{
var starCluster = new StarCluster
{
Id = state.ObjectId,
Name = state.Name,
Position = new Position(universe, state.LocalCoordinates),
};
var builder = new ObjectBuilder<StarCluster>(starCluster);
builder.Resolve((resolver, target) => target.MarketPlace = Market.MarketPlace.Builder.Build(state.MarketPlace, starCluster).Build(resolver));
builder
.Dependents(state.SolarSystems)
.Build(SolarSystem.Builder.Build)
.Resolve((resolver, target, dependent) => target.SolarSystems.Add(dependent));
return builder;
}
public void ShouldBeAbleToUseDoMultiple()
{
var builderSetup = new BuilderSettings();
var myClass = Substitute.For <IMyInterface>();
var list = new List <IMyOtherInterface> {
Substitute.For <IMyOtherInterface>(), Substitute.For <IMyOtherInterface>(), Substitute.For <IMyOtherInterface>()
};
var builder2 = new ObjectBuilder <IMyInterface>(reflectionUtil, builderSetup);
{
myClass.Add(Arg.Any <IMyOtherInterface>());
}
{
builder2.DoMultiple((x, y) => x.Add(y), list);
builder2.CallFunctions(myClass);
}
}
/// <summary>
/// Updates the child, return a boolean indicating whether any of the children has been updated.
/// </summary>
internal override bool UpdateChild(ObjectBuilder builder)
{
if (_dependencyProviders == null || _dependencyProviders.Length == 0)
{
return(false);
}
var result = false;
foreach (var dependencyProvider in _dependencyProviders)
{
if (!dependencyProvider.CanUpdateObjectBuilder(builder))
{
continue;
}
dependencyProvider.UpdateObjectBuilder(builder);
result = true;
}
return(result);
}
public void Deveria_Buscar_Permissoes_Por_Grupo()
{
var administrador = GroupRepository.GetById(1);
var permissao = ObjectBuilder.CreatePermission();
if (administrador.Claims.FirstOrDefault() == null)
administrador.Claims.Add(ObjectBuilder.CreateClaim());
administrador.Claims.First().Permissions.Add(permissao);
Uow.Commit();
var adminPermissions = PermissionRepository.GetByGroup(administrador.Id);
Assert.AreEqual(3, adminPermissions.Count);
var allPermissions = PermissionRepository.GetAll();
Assert.AreEqual(11, allPermissions.Count);
}
public void ShouldBeAbleToUseDoMultiple()
{
var myClass = mocks.DynamicMock <IMyInterface>();
var list = new List <IMyOtherInterface> {
mocks.Stub <IMyOtherInterface>(), mocks.Stub <IMyOtherInterface>(), mocks.Stub <IMyOtherInterface>()
};
var builder2 = new ObjectBuilder <IMyInterface>(reflectionUtil);
using (mocks.Record())
{
const int listSize = 3;
myClass.Expect(x => x.Add(Arg <IMyOtherInterface> .Is.TypeOf)).Repeat.Times(listSize);
}
using (mocks.Playback())
{
builder2.DoMultiple((x, y) => x.Add(y), list);
builder2.CallFunctions(myClass);
}
}
public static ObjectBuilder<MarketPlace> Build(MarketPlaceState state, StarCluster starCluster)
{
var marketPlace = new MarketPlace
{
AuctionLength = state.AuctionLength,
SettlementDelay = state.SettlementDelay,
StarCluster = starCluster,
};
var builder = new ObjectBuilder<MarketPlace>(marketPlace);
builder
.Dependents(state.Settlements)
.Build(Settlement.Builder.Build)
.Resolve((resolver, target, settlement) => target._settlements.Add(settlement));
builder
.Resolve((resolver, target) => target._auctions.AddRange(state.Auctions.Select(resolver.Get<Auction>)));
return builder;
}
public void A_reply_should_be_received_by_the_requestor()
{
ObjectBuilder.Stub(x => x.GetInstance <TestReplyService <PingMessage, Guid, PongMessage> >())
.Return(new TestReplyService <PingMessage, Guid, PongMessage> {
Bus = RemoteBus
});
RemoteBus.Subscribe <TestReplyService <PingMessage, Guid, PongMessage> >();
PingMessage message = new PingMessage();
TestCorrelatedConsumer <PongMessage, Guid> consumer = new TestCorrelatedConsumer <PongMessage, Guid>(message.CorrelationId);
LocalBus.Subscribe(consumer);
LocalBus.Publish(message);
TestConsumerBase <PingMessage> .AnyShouldHaveReceivedMessage(message, _timeout);
consumer.ShouldHaveReceivedMessage(new PongMessage(message.CorrelationId), _timeout);
}
public void ListTest() {
var builder = new ObjectBuilder<ObjectWithList>(new TypeTreeCache(new TypeTreeBuilder()), AllValueTypesProvider.ValueTypes);
var patches = new List<Patch>
{
new Patch() {Operation = "add", Path = "/Addresses/0", Value = ""},
new Patch() {Operation = "add", Path = "/Addresses/1", Value = ""},
new Patch() {Operation = "add", Path = "/Addresses/0/Users/0", Value = ""},
new Patch() {Operation = "add", Path = "/Addresses/0/Users/1", Value = ""},
//new Patch() {Operation = "replace", Path = "/Addresses/0/Street", Value = "1234"},
//new Patch() {Operation = "replace", Path = "/Addresses/0/Users/0/Name", Value = "1234"},
new Patch() {Operation = "remove", Path = "/Addresses/0/Users/0", Value = ""}
};
var watch = new Stopwatch();
watch.Start();
for (var i = 0; i < 100000; i++) {
var user = builder.Build(patches);
}
watch.Stop();
Trace.WriteLine(watch.ElapsedMilliseconds);
watch.Reset();
watch.Start();
for (var i = 0; i < 100000; i++)
{
var user = new User();
user.Addresses.Add(new Address());
user.Addresses[0].Street = "1234";
user.Addresses[0].Users.Add(new User());
user.Addresses[0].Users[0].Name = "1234";
user.Addresses[0].Users.RemoveAt(0);
}
watch.Stop();
Trace.WriteLine(watch.ElapsedMilliseconds);
}
/// <summary>
/// Set a anonymous object for variables.
/// </summary>
/// <param name="template">The <see cref="ITemplate"/>.</param>
/// <param name="key">The key of the element to get</param>
/// <param name="value">The value with the specified key.</param>
public static void SetAnonymousObject(this ITemplate template, string key, object value)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException(nameof(key));
}
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (template.EnableCompile)
{
var anonymousType = value.GetType();
var type = ObjectBuilder.GetOrGenerateType(anonymousType);
var newObj = ObjectBuilder.FromAnonymousObject(value, type);
template.Context.TempData.Set(key, newObj, type);
}
else
{
template.Context.TempData.Set(key, value, null);
}
}
public void PlaceTile(TileType type, int x, int y)
{
var vec = new Vector2Int(x, y);
if (_tiles.ContainsKey(vec))
{
Destroy(_tiles[vec].gameObject);
}
int tileId = (int)ObjectBuilder.Create(x, y).Number;
var go = ObjectBuilder.Get(tileId);
go.transform.parent = transform;
go.AddComponent <SpriteRenderer>().sprite = type.Sprite;
go.name = x + "_" + y + "_" + type.Name;
_tiles[vec] = go.AddComponent <Tile>();
_tiles[vec].Type = type;
if (type.Name == "Entry")
{
Entry = go.GetComponent <Tile>();
}
_tiles[vec].Position = vec;
}
public override void PushValues(TIn input, Action <TOut> push, CancellationToken cancellationToken, IDependencyResolver resolver, IInvoker invoker)
{
var selection = _args.GetSheetSelection(input);
// TODO: better exception handling here
var reader = _args.Mapping.GetExcelReader(selection.ExcelWorksheet);
int i = 0;
bool foundRow = false;
do
{
if (cancellationToken.IsCancellationRequested)
{
break;
}
IDictionary <string, object> row = new Dictionary <string, object>();
foundRow = ReadRow(selection.ExcelWorksheet, reader, i++, row);
if (foundRow)
{
push(_args.GetOutput(ObjectBuilder <TParsed> .CreateInstance(row), input));
}
} while (foundRow);
}
public void Simple() {
var builder = new ObjectBuilder<User>(new TypeTreeCache(new TypeTreeBuilder()), AllValueTypesProvider.ValueTypes);
var patches = new List<Patch>
{
new Patch() {Operation = "replace", Path = "/Name", Value = "Niclas"},
// new Patch() {Operation = "replace", Path = "/Address/Street", Value = "My street"}
};
var test = builder.Build(patches);
var watch = new Stopwatch();
watch.Start();
for (var i = 0; i < 500000; i++) {
var user = builder.Build(patches);
}
watch.Stop();
Trace.WriteLine(watch.ElapsedMilliseconds);
}
public void ShouldAdvertiseMethod()
{
var called = false;
var builder = new ObjectBuilder();
builder.AdvertiseMethod("test::v()", (signature, args) =>
{
called = true;
return(QiValue.Void);
});
using (var session = new Session())
{
session.Connect(new Uri("tcp://127.0.0.1:9559"));
var service = session.RegisterService("builderService", builder.BuildObject());
var service2 = session.GetService("builderService") as dynamic;
service2.test();
session.Close();
}
Assert.True(called);
}
public IWorkItemCommand BuildCommand(WorkItem item)
{
/*
* Specification:
* Only workitem type supported is the hotel work item.
* Incase null then throw..
* Incase unsupported type then throw
* Incase hotel work item then get command mapped corresponding to the data type + change type.
*/
if (item == null)
{
throw new InvalidParameterException("Work item cannot be null.");
}
if (item is HotelWorkItem == false)
{
throw new InvalidParameterException(string.Format("{0} is not a supported work item type for HotelWorkItemCommandFactory.", item == null ? "null" : item.GetType().Name));
}
var hotelWorkItem = item as HotelWorkItem;
var key = string.Format("{0}.{1}", hotelWorkItem.Schema, hotelWorkItem.ChangeType);
return(ObjectBuilder.BuildIfDefined <IWorkItemCommand>(key));
}
public void MasterWorkItemInputShouldBuildOnDataTypeAndChangeTypeTest()
{
var dataType = Unique.NewString;
var workItem = new MasterWorkItem()
{
Schema = dataType, ChangeType = ChangeType.Updated
};
var command = new Mock <IWorkItemCommand>().Object;
try
{
var key = string.Format("{0}.{1}", dataType, "Updated");
ObjectBuilder.RegisterInstance <IWorkItemCommand>(command, key);
IWorkItemCommandFactory commandFactory = new MasterWorkItemCommandFactory();
var cmd = commandFactory.BuildCommand(workItem);
Assert.IsTrue(cmd == command, "Incorrect command built by the factory for the given workitem.");
}
finally
{
ObjectBuilder.Reset();
}
}
// Write this object into message-out
internal override void Write(BinaryWriter binaryWriter)
{
base.Write(binaryWriter);
// Amount
if (float.IsNaN(Amount) || float.IsInfinity(Amount))
{
System.Diagnostics.Debug.Fail("Amount is: " + Amount);
Amount = DEFAULT_AMOUNT;
}
MyMwcLog.IfNetVerbose_AddToLog("Amount: " + Amount);
MyMwcMessageOut.WriteFloat(Amount, binaryWriter);
// Object builder
bool isObjectBuilder = ObjectBuilder != null;
MyMwcMessageOut.WriteBool(isObjectBuilder, binaryWriter);
if (isObjectBuilder)
{
ObjectBuilder.Write(binaryWriter);
}
}
/// <summary>
/// 根据每个类型实例的使用情况，获取指定类型的对象实例
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static T Acquire <T>()
where T : PoolableBase, new()
{
available = false;
T item = null;
bool increasable;
ObjectCache cache = new ObjectCache();
if (!(cache.TryToAcquire <T>(out item, out increasable)))
{
if (increasable)
{
ObjectBuilder <T> builder = new ObjectBuilder <T>();
item = builder.BuildUp();
cache.Cache <T>(item);
}
}
available = true;
return(item);
}
/// <summary>
/// Creates the view model instance.
/// </summary>
/// <param name="viewType">Type of the view.</param>
/// <param name="instance"></param>
/// <returns></returns>
internal static object CreateViewModelInstance(object instance)
{
Initialize();
Type viewType = instance.GetType();
if (!_viewModels.ContainsKey(viewType))
{
throw new InvalidOperationException("the associated view model is not found for this view !");
}
//var interfaces = viewType.GetInterfaces();
//if (interfaces.Length > 1)
//{
// if (interfaces[1].FullName == typeof(IView).FullName)
// {
// Container.Current.RegisterInstance(interfaces[0], instance);
// }
//}
return(ObjectBuilder.CreateObject(_viewModels[viewType]));
//return Container.Current.Resolve(_viewModels[viewType]); // ObjectBuilder.CreateObject(_viewModels[viewType]);
}
/// <summary>
/// Checks assertions depending on the concrete type of checker.
/// </summary>
public void CheckInterface()
{
var result = (TCloneable)ObjectBuilder.CreateInstance(typeof(TCloneable), Environment.TickCount, false);
ObjectFiller.Fill(result, false);
var clone = (TCloneable)result.Clone();
// Clone should be equal
Check.ThatObject(result).IsEqualTo(clone);
// Check if we change a property on a side it is not changed on other side
foreach (var info in typeof(TCloneable).GetProperties())
{
clone = (TCloneable)result.Clone();
if (ObjectModifier.ChangeValue(result, info.Name, true))
{
var type = result.GetType();
Check.ThatObject(info.GetValue(result)).IsNotEqualTo(
info.GetValue(clone),
$"After clone of {type}, property {info.Name} should not remain equal to the same property of original object");
}
}
}
private void SetupSubscriptionService()
{
SubscriptionService = new LocalSubscriptionService();
ObjectBuilder.Stub(x => x.GetInstance <IEndpointSubscriptionEvent>())
.Return(SubscriptionService);
ObjectBuilder.Stub(x => x.GetInstance <SubscriptionPublisher>())
.Return(null)
.WhenCalled(invocation =>
{
// Return a unique instance of this class
invocation.ReturnValue = new SubscriptionPublisher(SubscriptionService);
});
ObjectBuilder.Stub(x => x.GetInstance <SubscriptionConsumer>())
.Return(null)
.WhenCalled(invocation =>
{
// Return a unique instance of this class
invocation.ReturnValue = new SubscriptionConsumer(SubscriptionService, EndpointFactory);
});
}
public static ObjectBuilder<Settlement> Build(SettlementState state)
{
var settlement = new Settlement
{
Id = state.ObjectId,
Name = state.Name,
Timer = state.TimeToSettlement,
};
var builder = new ObjectBuilder<Settlement>(settlement);
builder
.Dependent(state.Item)
.Build(item => Item.Builder.Build(item))
.Resolve((resolver, target, item) => item.Location = resolver.Get<ILocation>(state.Location))
.Resolve((resolver, target, item) => item.Owner = resolver.Get<Corporation>(state.Owner))
.Resolve((resolver, target, item) => target._item = item);
builder
.Resolve((resolver, target) => SpendByOwner(resolver, target, state.SpendByOwner));
return builder;
}
public static ObjectBuilder<Ship> Build(ILocation location, ShipState state)
{
var ship = new Ship
{
Id = state.ObjectId,
Name = state.Name,
Heading = state.Heading,
Position = new Position(location, state.LocalCoordinates),
Statistics = new ShipStatistics(state.Statistics.Select(Build)),
};
var builder = new ObjectBuilder<Ship>(ship)
.Resolve((resolver, target) => BuildHardPoints(resolver, ship, state.HardPoints))
.Resolve((resolver, target) => target.ShipInfo = resolver.Get<ShipInfo>(ItemType.Ships.ToObjectReference(state.Code)));
builder
.Dependent(state.Pilot)
.Build(Agent.Builder.Build)
.Resolve((resolver, target, dependentObject) => target.Pilot = dependentObject);
return builder;
}
void Awake()
{
dropdownDictionary = new Dictionary <int, string>();
symbolDictionary = new Dictionary <string, int>();
FillSymbolDropdown(ref symbolDropdown, ref dropdownDictionary, typeof(Parametric_Turtle));
foreach (KeyValuePair <int, string> kvp in dropdownDictionary)
{
symbolDictionary[kvp.Value] = kvp.Key;
}
PanelList = new List <GameObject>();
PanelList.Add(ObjectPanel);
PanelList.Add(DrawPanel);
PanelList.Add(JointPanel);
PanelList.Add(RotationPanel);
lineBuilder = DrawPanel.GetComponent <LineBuilder>();
objectBuilder = ObjectPanel.GetComponent <ObjectBuilder>();
jointBuilder = JointPanel.GetComponent <JointBuilder>();
rotationBuilder = RotationPanel.GetComponent <RotationBuilder>();
growthBuilder = GrowthPanel.GetComponent <GrowthBuilder>();
}
public void RecursiveInstantiation()
{
Mockery mocks = new Mockery();
IDataReader reader = mocks.NewMock<IDataReader>();
Expect.Once.On(reader)
.Method("Read")
.Will(Return.Value(true));
Expect.Once.On(reader)
.Get["product_id"]
.Will(Return.Value("12"));
Expect.Once.On(reader)
.Get["product_name"]
.Will(Return.Value("Widgets"));
Expect.Once.On(reader)
.Get["supplier_id"]
.Will(Return.Value("6"));
Expect.Once.On(reader)
.Get["supplier_name"]
.Will(Return.Value("Wallace's Widgets & Co."));
Expect.Once.On(reader)
.Method("Read")
.Will(Return.Value(false));
ObjectBuilder<Product> products = new ObjectBuilder<Product>(reader);
Product product = products.Single();
Assert.AreEqual(12, product.ID);
Assert.AreEqual("Widgets", product.Name);
Assert.IsInstanceOf(typeof(Supplier), product.MainSupplier);
}
public virtual void SetValueNull <T>(string name, T value, CultureInfo culture = null)
{
if (!IsPropertyDefined(name))
{
throw new Exception(String.Format(
"Type '{0}' does not contains definition for name '{1}'", _type, name));
}
MetaDataProperty property = GetProperty(name, culture, true);
object oldValue = property.Value;
var newValue = ObjectBuilder.BuildObjectValue <T>(value);
property.Value = newValue;
// ReSharper disable CompareNonConstrainedGenericWithNull
bool changed = oldValue == null
? newValue != null
: !oldValue.Equals(newValue);
// ReSharper restore CompareNonConstrainedGenericWithNull
IsChanged = IsChanged || changed;
}
/// <summary>
/// Loads the object info.
/// </summary>
/// <param name="tables">The tables.</param>
/// <param name="columns">The columns.</param>
/// <param name="table">The table.</param>
/// <returns></returns>
protected virtual DBObject LoadObjectInfo(QueryRow table, QueryData columns)
{
DBObject t = new DBObject();
ObjectBuilder.SetFieldData(_dstore, table, t);
t.Columns = new List <Column>();
foreach (QueryRow row in columns) //all of the columns for all of the tables were returned, so we need to only get the one I'm working on...
{
if (row.FieldHasMapping("TableName")) //make sure the table name is present
{
if (row.GetDataForRowField("TableName").ToString().Equals(t.Name, StringComparison.InvariantCultureIgnoreCase) &&
row.GetDataForRowField("Schema").ToString().Equals(t.Schema, StringComparison.InvariantCultureIgnoreCase)) //make sure its the right table
{
if (row.FieldHasMapping("ColumnName"))
{
AddColumnToDBObject(row, t);
}
}
}
}
return(t);
}
public IHttpActionResult Post()
{
AuthenticatedUser user = authenticate.confirmToken();
try
{
if (user.UserID != 0)
{
ObjectBuilder listBuilder = new ObjectBuilder();
SurveyQueries query = new SurveyQueries();
List <Answer> answers = listBuilder.BuildAnswerList(HttpContext.Current.Request["answers"]);
}
else
{
return(Unauthorized());
}
return(Ok("success"));
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
private static ComponentFactory GetObjectBuilderOf(ILake lake, Type t)
{
if (lake is null)
{
throw new ArgumentNullException(nameof(lake));
}
if (t is null)
{
throw new ArgumentNullException(nameof(t));
}
if (t.IsInterface || t.IsAbstract)
{
throw new InvalidOperationException("Could not create instance of interface or abstract class");
}
return(() =>
{
ObjectBuilder objBuilder = new ObjectBuilder(t, lake);
var obj = objBuilder.Build();
return obj;
});
}
public void TestMetaDataSerialization()
{
var metaData = new TypeMetaData();
metaData.StoreFieldNumber("blah/", "myName", "someField", 2);
var serializer = ObjectBuilder.GetSerializer();
var result = serializer.Serialize(metaData, AppModeType);
Assert.IsTrue(result.Data.Length > 0, "Meta data was not successfully serialized. The resultant byte count was zero.");
var deserialized = serializer.Deserialize <TypeMetaData>(result.Data, AppModeType);
Assert.IsNotNull(deserialized, "Deserialization was not succesfull, the resultant object was null.");
int?fieldNumber;
var success = deserialized.GetFieldNumber("blah/", "myName", "someField", out fieldNumber);
Assert.IsTrue(success, "The expected field number was not found in the deserialized data. MetaData deserialization failed.");
Assert.AreEqual(2, fieldNumber.Value, "The expected field number was not found in the deserialized data. MetaData deserialization failed.");
}
private void buildObject(int random)
{
ObjectBuilder obj = new ObjectBuilder(cube, normalCoin, gate); // -----> Normal Coin, 79%.. {1, 2, ..... 78, 79}
if (random > 98) // ---------------------------------------------------> Purple Coin, 2%.. {99, 100}
{
obj = new ObjectBuilder(cube, purpleCoin, gate);
}
else if (random > 93) // ----------------------------------------------> Green Coin, 5%.. {94, 95, 96, 97, 98}
{
obj = new ObjectBuilder(cube, greenCoin, gate);
}
else if (random > 80) // ----------------------------------------------> Red Coin, 10%.. {81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93}
{
obj = new ObjectBuilder(cube, redCoin, gate);
}
else if (random == 80) // ---------------------------------------------> Immune Spell, 1%.. {80}
{
obj = new ObjectBuilder(cube, spellCoin, gate);
}
obj.insert();
}
public Form1()
{
InitializeComponent();
this.SetStyle(ControlStyles.UserPaint, true);
this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
int x = 50;
int y = 50;
IGrahObject car = new ObjectBuilder();
car.Children.Add(new Rectangle(x, y));
car.Children.Add(new Ellipse(x, y + 25));
car.Children.Add(new Ellipse(x + 40, y + 25));
IGrahObject player = new ObjectBuilder();
player.Children.Add(new Rectangle(x + 100, y));
player.Children.Add(new Ellipse(x + 150, y + 10));
player.Children.Add(new Ellipse(x + 135, y + 10));
world.Children.Add(car);
world.Children.Add(new Rectangle(x, y + 200));
world.Children.Add(player);
}
/// <summary>
/// Log in the user
/// </summary>
/// <param name="username"></param>
/// <param name="password"></param>
/// <returns></returns>
public async Task <User> LoginUser(string username, string password)
{
User user = new User
{
USER_NAME = username,
PASSWORD = password,
};
Dictionary <string, object> loginPost = new Dictionary <string, object>
{
{ "USER_NAME", user.USER_NAME },
{ "PASSWORD", user.PASSWORD },
{ "RETURN_MODEL", "YES" },
};
_restResponse = await _rest.PostRequest("v1/users/login", loginPost);
User userModel = ObjectBuilder.BuildUserObject(_restResponse);
return(userModel);
}
/// <summary>
/// Start a Unit of Work
/// is called
/// </summary>
/// <returns>
/// An IUnitOfwork object that can be used to work with the current UoW.
/// </returns>
public static IUnitOfWork Start(UnitOfWorkNestingOptions nestingOptions)
{
if (_globalNonThreadSafeUnitOfwork != null)
{
return(_globalNonThreadSafeUnitOfwork);
}
UnitOfWorkAdapter unitOfWorkAdapter = (UnitOfWorkAdapter)ServerContext.Request[CurrentUnitOfWorkKey];
if (nestingOptions == UnitOfWorkNestingOptions.ReturnExistingOrCreateUnitOfWork &&
unitOfWorkAdapter != null)
{
unitOfWorkAdapter.IncremementUsages();
return(unitOfWorkAdapter);
}
UnitOfWorkAdapter previous = unitOfWorkAdapter;
unitOfWorkAdapter = ObjectBuilder.Get <UnitOfWorkAdapter>();
unitOfWorkAdapter.SetPrevious(previous);
return(unitOfWorkAdapter);
}
public void Deveria_Adicionar_Autorizacao_ao_Grupo()
{
var grupo = GroupRepository.GetByIdIncluding(2, g => g.Claims);
var claims = ObjectBuilder.CreateListClaim();
var claimsDTO = new List <ClaimDTO>();
claims.ForEach((autho) =>
{
ClaimRepository.Add(autho);
claimsDTO.Add(new ClaimDTO(autho));
});
Uow.Commit();
AuthorizationService.AddAuthorizationToGroup(grupo.Id, claimsDTO.ToArray());
//Test authorization in group
var authorize = ClaimRepository.GetByGroup(2);
grupo = GroupRepository.GetByIdIncluding(2, g => g.Claims);
Assert.IsNotNull(authorize);
Assert.AreEqual(4, grupo.Claims.Count);
}
public Task <ExecutionStatus> ExecuteAsync(string className, string @namespace, string streamTransformationName, Dictionary <string, string> parameters, Action <TraceEvent> processTraceEvent)
{
// Task<ExecutionStatus> ExecuteWithNoFaultAsync(object config, Action<IStream<TraceEvent>> traceProcessDefinition = null);
var process = Processes
.First(i =>
i.Summary.ClassName == className &&
i.Summary.Namespace == @namespace &&
i.Summary.StreamTransformationName == streamTransformationName);
var action = process.StreamTransformationMethodInfo.CreateDelegate(typeof(Action <>).MakeGenericType(typeof(ISingleStream <>).MakeGenericType(process.StreamConfigType)));
var processRunner = Activator.CreateInstance(typeof(StreamProcessRunner <>).MakeGenericType(process.StreamConfigType), action, process.Summary.StreamTransformationName) as IStreamProcessRunner;
Action <IStream <TraceEvent> > traceProcessDefinition = (IStream <TraceEvent> str) => str.ThroughAction("", processTraceEvent);
var ob = new ObjectBuilder(process.StreamConfigType);
foreach (var parameter in parameters)
{
ob.Values[parameter.Key] = TypeDescriptor.GetConverter(ob.Types[parameter.Key]).ConvertFromString(parameter.Value);
}
// .CreateInstance()
return(processRunner.ExecuteWithNoFaultAsync(ob.CreateInstance(), traceProcessDefinition));
}
public void SimpleModelTest()
{
var model = new TestModelSimple()
{
TestProperty1 = "Eureka!!!",
TestProperty2 = 2,
OtherFieldInfo = new DateTime(1985, 6, 15),
Ints = new List <int>()
{
1, 2
}
};
var ser = ObjectBuilder.GetSerializer();
var result = ser.Serialize(model, AppModeType);
Assert.IsNotNull(result);
Assert.IsNotNull(result.Data);
Assert.IsNotNull(result.MetaData);
Assert.IsTrue(result.Data.Length > 0, "Serialized data length must be greater than 0, serialization failed.");
var counterpart = ser.Deserialize <Models.Counterparts.TestModelSimple>(result.Data, result.MetaData, AppModeType);
Assert.AreEqual(model.TestProperty1, counterpart.TestProperty1);
Assert.AreEqual(model.TestProperty2, counterpart.TestProperty2);
Assert.AreEqual(model.OtherFieldInfo, counterpart.OtherFieldInfo);
Assert.IsNotNull(counterpart.Ints);
Assert.AreEqual(model.Ints.Count, counterpart.Ints.Length);
for (var i = 0; i < model.Ints.Count; i++)
{
Assert.AreEqual(model.Ints[i], counterpart.Ints[i]);
}
}
private void ProcessEndOfNode(Stack <NodeLevel> nodes, string text, Action <XmlNodeParsed> pushResult, string sourceName)
{
string key = ComputeKey(nodes);
if (_xmlFieldsDefinitionSearch.Contains(key))
{
ProcessAttributeValue(key, nodes, text);
}
else if (_xmlNodesDefinitionSearch.Contains(key))
{
var nd = _xmlFileDefinition.XmlNodeDefinitions.FirstOrDefault(i => i.NodePath == key);
var objectBuilder = new ObjectBuilder(nd.Type);
foreach (var inScopeReadField in _inScopeReadFields.Where(rf => rf.NodeDefinition.NodePath == key))
{
objectBuilder.Values[inScopeReadField.Definition.TargetPropertyInfo.Name] = inScopeReadField.Value;
}
foreach (var propName in nd.GetXmlFieldDefinitions().Where(i => i.ForRowGuid).Select(i => i.TargetPropertyInfo.Name).ToList())
{
objectBuilder.Values[propName] = Guid.NewGuid();
}
foreach (var propName in nd.GetXmlFieldDefinitions().Where(i => i.ForSourceName).Select(i => i.TargetPropertyInfo.Name).ToList())
{
objectBuilder.Values[propName] = sourceName;
}
pushResult(new XmlNodeParsed
{
NodeDefinitionName = nd.Name,
SourceName = sourceName,
NodePath = nd.NodePath,
Type = nd.Type,
Value = objectBuilder.CreateInstance(),
CorrelationKeys = nodes.Select(i => i.Guid).Where(i => i.HasValue).Select(i => i.Value).ToHashSet()
});
}
ProcessEndOfAnyNode(nodes);
}
public virtual void Play(Actor source, List <Actor> targets, BattleContext mgr)
{
foreach (Actor actor in targets)
{
// Run effects
if (null != _targetEffectList)
{
foreach (JClassInfo property in _targetEffectList)
{
// 創建Effect
ObjectBuilder effectBuilder = new ObjectBuilder(property.Name);
foreach (JKeyValuePair attributes in property.Properties)
{
effectBuilder.SetProperty(attributes.Key, attributes.Value);
}
ICardAction effect = (ICardAction)effectBuilder.Build();
effect.RunAction(source, actor, this, mgr);
}
}
// Run effects
if (null != _sourceEffectList)
{
foreach (JClassInfo property in _sourceEffectList)
{
// 創建Effect
ObjectBuilder effectBuilder = new ObjectBuilder(property.Name);
foreach (JKeyValuePair attributes in property.Properties)
{
effectBuilder.SetProperty(attributes.Key, attributes.Value);
}
ICardAction effect = (ICardAction)effectBuilder.Build();
effect.RunAction(actor, source, this, mgr);
}
}
}
}
public NestedPropertyHandler(ObjectBuilder builder)
: base(builder)
{
}
public EndOfInstanceHandler(ObjectBuilder builder)
: base(builder)
{
}
public DoublePropertyHandler(ObjectBuilder builder)
: base(builder)
{
}
public void ShouldBeAbleToUseDoMultiple()
{
var myClass = mocks.DynamicMock<IMyInterface>();
var list = new List<IMyOtherInterface> { mocks.Stub<IMyOtherInterface>(), mocks.Stub<IMyOtherInterface>(), mocks.Stub<IMyOtherInterface>() };
var builder2 = new ObjectBuilder<IMyInterface>(reflectionUtil);
using (mocks.Record())
{
const int listSize = 3;
myClass.Expect(x => x.Add(Arg<IMyOtherInterface>.Is.TypeOf)).Repeat.Times(listSize);
}
using (mocks.Playback())
{
builder2.DoMultiple((x, y) => x.Add(y), list);
builder2.CallFunctions(myClass);
}
}
public SimpleObjectReader(TextReader reader)
{
this.reader = reader;
builder = new ObjectBuilder();
}
public MockObjectCreationStrategy(ObjectBuilder objectBuilder)
{
_objectBuilder = objectBuilder;
}
public IntPropertyHandler(ObjectBuilder builder)
: base(builder)
{
}
public ActivatorCreationStrategy(ObjectBuilder objectBuilder, ArgumentsForConstructors argumentsForConstructors, TestConfig testConfig)
{
_objectBuilder = objectBuilder;
_argumentsForConstructors = argumentsForConstructors;
_testConfig = testConfig;
}
public override void Initialize(ObjectBuilder objectBuilder)
{
}
public SearchForAnImplementationCreationStrategy(ObjectBuilder objectBuilder)
{
_objectBuilder = objectBuilder;
}
protected AbstractLineHandler(ObjectBuilder builder) {
Builder = builder;
}
