private static IJavaScriptCompiler GetCompiler()
{
var jsRuntimeProvider = new InstanceProvider <IJavaScriptRuntime>(() => new IEJavaScriptRuntime());
var compilerProvider = new InstanceProvider <IJavaScriptCompiler>(() => new CoffeeScriptCompiler(jsRuntimeProvider));
return(compilerProvider.GetInstance());
}
public static DataView GetCustomUrls(Guid organizationId)
{
using (CustomUrlTableAdapter adapter = new CustomUrlTableAdapter())
{
MasterDataSet.CustomUrlDataTable table = adapter.GetCustomUrlsByOrganizationId(organizationId);
table.Columns.Add("Name", typeof(string));
Organization org = null;
foreach (MasterDataSet.CustomUrlRow row in table)
{
if (org == null)
{
org = OrganizationProvider.GetOrganization(organizationId);
}
string name = string.Empty;
if (row.IsInstanceIdNull())
{
name = org.Name;
}
else
{
Instance inst = InstanceProvider.GetInstance(row.InstanceId);
if (inst != null)
{
name = inst.Name;
}
}
row["Name"] = name;
}
table.DefaultView.Sort = string.Format(CultureInfo.InvariantCulture, "{0}, Name", table.InstanceIdColumn.ColumnName);
return(table.DefaultView);
}
}
public void VehicleCanMove()
{
var factory = InstanceProvider.GetInstance <VehicleFactory>();
foreach (var vehicle in factory.CreateAllVehicles())
{
//All vehicles should start at 0,0
Assert.AreEqual(vehicle.CurrentPosition, new Point(0, 0));
vehicle.MoveForward(1);
Assert.AreEqual(vehicle.CurrentPosition, new Point(0, 1));
vehicle.TurnRight();
vehicle.TurnRight();
vehicle.MoveForward(8);
Assert.AreEqual(vehicle.CurrentPosition, new Point(0, -7));
vehicle.TurnLeft();
vehicle.MoveForward(5);
Assert.AreEqual(vehicle.CurrentPosition, new Point(5, -7));
}
}
/// <summary>
/// The entry point for a unit test, represents the basic structure of a test-case.
/// </summary>
/// <remarks>
/// This is mostly structural code for the unit tests.
/// </remarks>
/// <param name="carType">The car type to use</param>
/// <param name="age">The age of the car</param>
/// <param name="accidents">The number of accidents</param>
/// <param name="market">The market to sell on</param>
/// <param name="service">(Optional) Specify a service to run against, leaving this blank will create one.</param>
/// <returns></returns>
private decimal BasicTest(
CarType carType,
int age = 0,
int accidents = 0,
CarMarket market = CarMarket.Lot,
Improve service = null)
{
// Construct the advertisement to test
var advertisement = new CarAdvertisement()
{
Type = carType,
Age = age,
Accidents = accidents,
SellingMarket = market
};
// If the service wasn't provided, let's provide one.
if (service == null)
{
// Request an instance from the provider.
service = InstanceProvider.GetInstance <Improve>(() => new Improve(_auctionService));
}
// Run the test case
return(service.GetSellingPrice(advertisement));
}
public void Intercept(IInvocation invocation)
{
if (invocation.Method.ReturnType == typeof(void))
{
_logger.Error($"{invocation.Method.Name} has no return type.");
}
invocation.ReturnValue = _provider.GetInstance(invocation.Method.ReturnType);
}
/// <summary>
/// Gets the service to test, optionally with a provided initial message state.
/// </summary>
/// <param name="messages"></param>
/// <returns></returns>
private Service GetService(IDictionary <string, IList <string> > messages = null)
{
var messageStore =
messages != null
? new InboxMessageStore(messages)
: new InboxMessageStore();
return(InstanceProvider.GetInstance <Service>(() => new Service(messageStore)));
}
public static void InitializeAssembly(TestContext context)
{
var registrations = InstanceProvider.GetInstance <Registrations>();
if (registrations != null)
{
registrations.Intercept();
}
}
/// <summary>
/// Gets the JS engine used to compile the script
/// </summary>
/// <returns></returns>
internal IJavaScriptRuntime GetEngine()
{
var jsRuntime = new InstanceProvider<IJavaScriptRuntime>(() => new IEJavaScriptRuntime());
var instance = jsRuntime.GetInstance();
instance.Initialize();
instance.LoadLibrary(JsLibs.typescript_min);
instance.LoadLibrary(JsLibs.compiler);
return instance;
}
/// <summary>
/// Gets the JS engine used to compile the script
/// </summary>
/// <returns></returns>
internal IJavaScriptRuntime GetEngine()
{
var jsRuntime = new InstanceProvider <IJavaScriptRuntime>(() => new IEJavaScriptRuntime());
var instance = jsRuntime.GetInstance();
instance.Initialize();
instance.LoadLibrary(JsLibs.typescript_min);
instance.LoadLibrary(JsLibs.compiler);
return(instance);
}
public string Execute(RenderContext context, string input)
{
var jsRuntimeProvider = new InstanceProvider <IJavaScriptRuntime>(
() => new IEJavaScriptRuntime());
var instance = new InstanceProvider <IJavaScriptCompiler>(
() => new TypeScriptCompiler(jsRuntimeProvider));
return(instance.GetInstance().Compile(input));
}
public void InstanceProvider_GetInstance()
{
// Arrange
var expected = new Test();
// Act
var provider = new InstanceProvider(expected);
var actual = provider.GetInstance();
//Assert
Assert.AreEqual(expected, actual);
}
public void At(string key)
{
var instance = InstanceProvider.GetInstance <Instances.Caching.Cache>();
if (_timeSpan.Ticks == 0)
{
instance.Add(key, _item);
}
else
{
instance.Add(key, _item, _timeSpan);
}
}
public void AuctionMarket_PerformanceOptimization_MixedCalls()
{
// Introduce an artificial delay
_auctionService.Delay = 1000;
// Modify the behavior of the auction service
_auctionService.Intercept = (t, a) =>
{
if (t == CarType.Sedan)
{
return(500m * (a + 1));
}
if (t == CarType.Coupe)
{
return(400m * (a + 1));
}
if (t == CarType.Hatchback)
{
return(300m * (a + 1));
}
if (t == CarType.PickupTruck)
{
return(200m * (a + 1));
}
return(0m);
};
var service = InstanceProvider.GetInstance <Improve>(() => new Improve(_auctionService));
var timer = Stopwatch.StartNew();
Assert.AreEqual(08000.00m, BasicTest(CarType.Sedan, market: CarMarket.Auction, service: service));
Assert.AreEqual(08100.00m, BasicTest(CarType.Coupe, market: CarMarket.Auction, service: service, accidents: 3));
Assert.AreEqual(08000.00m, BasicTest(CarType.Sedan, market: CarMarket.Auction, service: service));
Assert.AreEqual(08100.00m, BasicTest(CarType.Coupe, market: CarMarket.Auction, service: service, accidents: 3));
Assert.AreEqual(08000.00m, BasicTest(CarType.Sedan, market: CarMarket.Auction, service: service));
Assert.AreEqual(08100.00m, BasicTest(CarType.Coupe, market: CarMarket.Auction, service: service, accidents: 3));
Assert.AreEqual(08000.00m, BasicTest(CarType.Sedan, market: CarMarket.Auction, service: service));
Assert.AreEqual(08100.00m, BasicTest(CarType.Coupe, market: CarMarket.Auction, service: service, accidents: 3));
Assert.AreEqual(08000.00m, BasicTest(CarType.Sedan, market: CarMarket.Auction, service: service));
Assert.AreEqual(08100.00m, BasicTest(CarType.Coupe, market: CarMarket.Auction, service: service, accidents: 3));
timer.Stop();
Console.WriteLine($"Test ran in {timer.Elapsed}.");
}
public Channel <TChannel> GetChannel(TChannel message)
{
TInstance instance = _instanceProvider.GetInstance(message);
Channel <TChannel> channel = _accessor(instance);
if (channel == null)
{
throw new InvalidOperationException("The channel on the consumer {0} is null: {1}"
.FormatWith(typeof(TInstance).Name, typeof(TChannel).Name));
}
return(channel);
}
public ResponseObject <T> Make <T>(Func <T> method)
{
try
{
var data = method();
return(InstanceProvider.GetInstance <ResponseObject <T>, T>(data));
}
catch
{
var response = InstanceProvider.GetInstance <ResponseObject <T> >();
response.Errors.Add(Errors.Keys.Unknown, Errors.Values.Unknown);
return(response);
}
}
public void DiggingPostConstructor()
{
_placeBlockCursor = InstanceProvider.GetInstance <BlockMarker>();
_placeBlockCursor.Init("BuildCursor", WorldSettings.BuildMaterial);
_placeBlockCursor.SetBlockId((byte)InventoryModel.SelectedBlockType);
_mineBlockCursor = InstanceProvider.GetInstance <BlockMarker>();
_mineBlockCursor.Init("MineCursor", WorldSettings.MineMaterial);
_mineBlockCursor.SetMiningProgress(0);
Updater.EveryFrame(UpdateCursorBlocks);
Updater.EveryFrame(UpdateMining);
BlockTypeSelectedSignal.AddListener(BlockTypeSelectedHandler);
}
public void VehicleCanHonk()
{
var factory = InstanceProvider.GetInstance <VehicleFactory>();
var car = factory.CreateVehicle(VehicleType.Car);
Assert.AreEqual("honk", car.SoundHorn());
var truck = factory.CreateVehicle(VehicleType.Truck);
Assert.AreEqual("braap", truck.SoundHorn());
var motorbike = factory.CreateVehicle(VehicleType.Motorbike);
Assert.AreEqual("beep", motorbike.SoundHorn());
}
public void VehicleHasRightNumberOfWheels()
{
var factory = InstanceProvider.GetInstance <VehicleFactory>();
var car = factory.CreateVehicle(VehicleType.Car);
Assert.AreEqual(4, car.NumberOfWheels);
var truck = factory.CreateVehicle(VehicleType.Truck);
Assert.AreEqual(4, truck.NumberOfWheels);
var motorbike = factory.CreateVehicle(VehicleType.Motorbike);
Assert.AreEqual(2, motorbike.NumberOfWheels);
}
internal static void LogReturn(MethodInfo methodInfo, object returnValue, long elapsedMilliseconds)
{
var logInstance = InstanceProvider.GetInstance <Logger>();
if (logInstance.LogLevel != LogLevel.Debug && logInstance.LogLevel != LogLevel.Info)
{
return;
}
if (logInstance.LogLevel == LogLevel.Debug)
{
logInstance.LogDebug(string.Format("<-[{0}]: ({1}) [{2}ms]", methodInfo.Name, JsonSerializer.Serialize(returnValue), elapsedMilliseconds), null);
}
else
{
logInstance.LogInfo(string.Format("<-[{0}] [{1}ms]", methodInfo.Name, elapsedMilliseconds), null);
}
}
internal override object Invoke(ProxyMethodCall methodCall)
{
object ret;
InstanceProvider.GetInstance <Persistence>().BeginTransaction();
try
{
ret = Next(methodCall);
}
catch (Exception)
{
InstanceProvider.GetInstance <Persistence>().RollbackTransaction();
throw;
}
InstanceProvider.GetInstance <Persistence>().CommitTransaction();
return(ret);
}
public void CanCreateDifferentVehicles()
{
var factory = InstanceProvider.GetInstance <VehicleFactory>();
var car = factory.CreateVehicle(VehicleType.Car);
Assert.IsNotNull(car);
Assert.AreEqual(VehicleType.Car, car.VehicleType);
var truck = factory.CreateVehicle(VehicleType.Truck);
Assert.IsNotNull(truck);
Assert.AreEqual(VehicleType.Truck, truck.VehicleType);
var motorbike = factory.CreateVehicle(VehicleType.Motorbike);
Assert.IsNotNull(motorbike);
Assert.AreEqual(VehicleType.Motorbike, motorbike.VehicleType);
}
public void SortByFileSize_HandlesNonUniformInput()
{
var algorithm = InstanceProvider.GetInstance <FileSizeSorter>();
var sorted = algorithm.Sort(FileSizeHelper.SampleValuesWithImperfections).ToArray();
Assert.IsNotNull(sorted,
"Your method returned a null result.");
Assert.AreEqual(FileSizeHelper.SampleValuesWithImperfections.Length, sorted.Length,
"Your method returned a differnet number of results than what was provided.");
try
{
FileSizeHelper.AssertIsSorted(sorted, withImperfections: true);
}
catch (FileSizeHelper.OutOfOrderException ex)
{
Assert.Fail(ex.Message);
}
}
internal static void LogException(MethodInfo methodInfo, Exception ex, long elapsedMilliseconds)
{
var logInstance = InstanceProvider.GetInstance <Logger>();
if (logInstance.LogLevel != LogLevel.Debug && logInstance.LogLevel != LogLevel.Info)
{
return;
}
if (logInstance.LogLevel == LogLevel.Debug)
{
logInstance.LogDebug(string.Format("x [{0}]: {1} [{2}ms]", methodInfo.Name, ex.Message, elapsedMilliseconds), ex);
}
if (logInstance.LogLevel == LogLevel.Info)
{
logInstance.LogInfo(string.Format("x [{0}]: {1} [{2}ms]", methodInfo.Name, ex.Message, elapsedMilliseconds), ex);
}
}
protected override void EditForm_ItemUpdated(object sender, DetailsViewUpdatedEventArgs e)
{
base.EditForm_ItemUpdated(sender, e);
if (e == null)
{
return;
}
if (e.Exception != null)
{
return;
}
if (m_UserContext.IsFrameworkAdministrator)
{
ComboBox cmb = EditForm.FindControl("cmbBillingPlan") as ComboBox;
int val = 0;
if (cmb != null && int.TryParse(cmb.SelectedValue, out val))
{
Guid instId = (Guid)EditForm.DataKey[0];
Instance inst = m_UserContext.Instance;
if (inst == null || inst.InstanceId != instId)
{
inst = InstanceProvider.GetInstance(instId);
}
if (inst.BillingPlan != BillingPlan.Custom && val == 1)
{
InstanceProvider.UpdateInstance(inst, BillingPlan.Custom);
}
else if (inst.BillingPlan == BillingPlan.Custom && val == 0)
{
ChargifyNET.ChargifyConnect _chargify = ChargifyProvider.CreateChargify();
ChargifyNET.ISubscription _custSubscr = ChargifyProvider.GetCustomerSubscription(_chargify, inst.OrganizationId, inst.InstanceId);
SettingCollection settings = SettingProvider.GetAllPricedSettings(inst.OrganizationId, inst.InstanceId);
ChargifyProvider.UpdateSubscriptionAllocations(_chargify, _custSubscr != null ? _custSubscr.SubscriptionID : 0, inst, settings, settings);
}
}
}
this.Redirect();
}
/// <summary>
/// Renders the logo of the specified instance or organization and the logo of the copyright holder company.
/// </summary>
/// <param name="writer">The System.Web.UI.HtmlTextWriter to render content to.</param>
/// <param name="organizationId">The identifier of the organization to render logo of.</param>
/// <param name="organizationId">The identifier of the instance to render logo of.</param>
public static void RenderHeader(HtmlTextWriter writer, Guid organizationId, Guid instanceId)
{
if (FrameworkConfiguration.Current.WebApplication.MasterPage.Theme == Pages.MasterPageTheme.Modern)
{
return;
}
if (organizationId != Guid.Empty)
{
Organization org = OrganizationProvider.GetOrganization(organizationId);
if (org != null)
{
Instance inst = null;
if (FrameworkConfiguration.Current.WebApplication.EnableMultipleInstances)
{
if (instanceId != Guid.Empty)
{
inst = InstanceProvider.GetInstance(instanceId, organizationId);
}
}
HyperLink link = null;
CreateLogo(org, inst, ref link);
if (link != null)
{
RenderHeader(writer, link);
}
}
else
{
RenderHeader(writer);
}
}
else
{
RenderHeader(writer);
}
}
internal static void LogInvokation(MethodInfo methodInfo, object[] parametersValue)
{
var logInstance = InstanceProvider.GetInstance <Logger>();
if (logInstance.LogLevel != LogLevel.Debug && logInstance.LogLevel != LogLevel.Info)
{
return;
}
var sb = new StringBuilder();
var counter = 0;
foreach (var parameterInfo in methodInfo.GetParameters())
{
sb.Append(parameterInfo.Name);
if (logInstance.LogLevel == LogLevel.Debug)
{
sb.Append(" (");
sb.Append(JsonSerializer.Serialize(parametersValue[counter++]));
sb.Append(")");
}
sb.Append(", ");
}
if (counter > 0)
{
sb.Length = sb.Length - 2;
}
if (logInstance.LogLevel == LogLevel.Debug)
{
logInstance.LogDebug(string.Format("->[{0}]: {1}", methodInfo.Name, sb), null);
}
else
{
logInstance.LogInfo(string.Format("->[{0}]", methodInfo.Name), null);
}
}
public virtual void Save(T entity)
{
InstanceProvider.GetInstance <Instances.Persistence.Persistence>().Save(entity);
}
public bool CanCreateInstance(TChannel message, out T instance)
{
instance = _missingInstanceProvider.GetInstance(message);
return(true);
}
private static IJavaScriptCompiler GetCompiler()
{
var jsRuntimeProvider = new InstanceProvider<IJavaScriptRuntime>(() => new IEJavaScriptRuntime());
var compilerProvider = new InstanceProvider<IJavaScriptCompiler>(() => new CoffeeScriptCompiler(jsRuntimeProvider));
return compilerProvider.GetInstance();
}
public void ShouldThrowArgumentNullExceptionForNullAsInstanceContext()
{
var instanceProvider = new InstanceProvider(ServiceLocator.Default, typeof (ITestService), typeof (TestService));
ExceptionTester.CallMethodAndExpectException<ArgumentNullException>(() => instanceProvider.GetInstance(null));
}
public virtual IList <T> Get()
{
return(InstanceProvider.GetInstance <Instances.Persistence.Persistence>().Get <T>());
}
protected object GetUnderlayerPersistence()
{
return(InstanceProvider.GetInstance <Instances.Persistence.Persistence>().GetUnderlayerPersistenceObject());
}
public object At(string key)
{
return(InstanceProvider.GetInstance <Instances.Caching.Cache>().GetData(key));
}
