void Start()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(this.gameObject);
}
DontDestroyOnLoad(this.gameObject);
//비동기 작업 매서드를 초기화
m_fnReceiveHandler = new AsyncCallback(handleDataReceive);
m_fnSendHandler = new AsyncCallback(handleDataSend);
resolve = new Resolve();
Connect();
}
public async Task Should_propagate_resolved_value()
{
/* Given */
var builder = new ResolverBuilder();
builder
.Use((context, next) => next(context))
.Use((context, next) => next(context))
.Use((context, next) => next(context));
builder.Run(context => new ValueTask <IResolveResult>(Resolve.As(42)));
/* When */
var resolver = builder.Build();
var result = await resolver(null);
/* Then */
Assert.Equal(42, result.Value);
}
public void Should_leverage_factory_to_return_a_logger_to_the_client( )
{
ILog mockLog = mockery.DynamicMock <ILog>( );
ILogFactory mockLogFactory = mockery.DynamicMock <ILogFactory>( );
IDependencyContainer mockContainer = mockery.DynamicMock <IDependencyContainer>( );
using (mockery.Record( )) {
Expect.Call(mockContainer.GetMeAnImplementationOfAn <ILogFactory>( )).Return(mockLogFactory);
Expect.Call(mockLogFactory.CreateFor(typeof(LogTest))).Return(mockLog);
}
using (mockery.Playback( )) {
Resolve.InitializeWith(mockContainer);
ILog log = Log.For(this);
Assert.AreEqual(mockLog, log);
Resolve.InitializeWith(null);
}
}
/// <summary>Runs a delegate in a seperate thread.</summary>
/// <param name="run">The delegate to run in the background.</param>
/// <param name="resolve">The delegate for handling the completion of the background thread.</param>
public static IAsyncResult Thread(
Operation run,
Resolve resolve)
{
if (run == null)
{
throw new System.ArgumentNullException("run");
}
if (resolve == null)
{
throw new System.ArgumentNullException("resolve");
}
SynchronizationContext context = SynchronizationContext.Current;
return(run.BeginInvoke(
(IAsyncResult ar) => { context.Post((object state) => { resolve(ar); }, null); },
null));
}
public async Task Part2_BindResolvers_SchemaBuilder_Maps()
{
// Create builder and load sdl
var builder = new SchemaBuilder()
.Sdl(@"
type Query {
name: String
}
");
// Get query type
builder.GetQuery(out var query);
// Bind resolvers from ObjectTypeMap
builder.UseResolversAndSubscribers(
new ObjectTypeMap
{
{
query.Name, new FieldResolversMap
{
{
"name", context =>
{
var result = Resolve.As("Test");
return(new ValueTask <IResolverResult>(result));
}
}
}
}
});
// Build schema
var schema = builder.Build();
// Get resolver for Query.name field
var nameResolver = schema.GetResolver(schema.Query.Name, "name");
// Execute the resolver. This is normally handled by the executor.
var nameValue = await nameResolver(null);
Assert.Equal("Test", nameValue.Value);
}
static void Main(string[] args)
{
var credentials = new UserCredentials("admin", "changeit");
var connectionSettings = ConnectionSettings.Create()
.KeepReconnecting()
.KeepRetrying()
.FailOnNoServerResponse()
.WithConnectionTimeoutOf(TimeSpan.FromSeconds(20))
.SetOperationTimeoutTo(TimeSpan.FromSeconds(10))
.SetHeartbeatInterval(TimeSpan.FromSeconds(10))
.SetHeartbeatTimeout(TimeSpan.FromSeconds(20));
MemoryCache cache = new MemoryCache(new MemoryCacheOptions());
using (var connection = EventStoreConnection.Create("ConnectTo=tcp://admin:[email protected]:1113; HeartBeatTimeout=5000", connectionSettings))
{
connection.ConnectAsync().GetAwaiter().GetResult();
var subscription = connection.SubscribeToStreamFrom("$ce-ledgerEntry", StreamPosition.Start, CatchUpSubscriptionSettings.Default, (_, @event) =>
{
var deserializedEvent = JsonConvert.DeserializeObject(
Encoding.UTF8.GetString(@event.Event.Data),
Assembly.GetAssembly(typeof(PortfolioRenamed)).GetType(@event.Event.EventType),
new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All,
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new DictionaryAsArrayResolver()
});
new Projector <MemoryCache>(
Resolve.WhenEqualToHandlerMessageType(InMemoryInventoryOverviewProjection.Projection.Handlers)).
ProjectAsync(cache, deserializedEvent);
Console.WriteLine($"EVENT TYPE: {@event.Event.EventType}");
OutputCache(cache);
}, userCredentials: credentials);
Console.ReadKey();
}
}
public void CanCreateServiceResolutionExpressionFromConstructorExpression()
{
var module = new Module();
var definition = new ServiceDefinition(
typeof(IServiceWithDependencies),
implementationFactory: req => new ServiceWithDependencies(
Resolve.From <IServiceWithoutDependencies>(),
"Hello world"
)
);
module.Add(definition);
module.Define <IServiceWithoutDependencies>().As <ServiceWithoutDependencies>();
var configuration = new Configuration(_options, module);
var container = configuration.CreateContainer();
var service = container.GetService <IServiceWithDependencies>();
Assert.Equal("Hello world", service.Message);
Assert.IsType <ServiceWithoutDependencies>(service.Dependency);
}
public static ResolveViewModel MapViewModel(this Resolve resolve, IMapper mapper, ICollection <UploadFile> attachmentsList = null)
{
if (attachmentsList.HasItems())
{
resolve.LoadAttachments(attachmentsList);
}
var model = mapper.Map <ResolveViewModel>(resolve);
if (!String.IsNullOrEmpty(model.Highlight))
{
model.Highlights = JsonConvert.DeserializeObject <ICollection <string> >(model.Highlight);
}
if (!String.IsNullOrEmpty(model.Source))
{
model.Sources = JsonConvert.DeserializeObject <ICollection <SourceViewModel> >(model.Source);
}
return(model);
}
public void ShouldLoad1000RowsInUnder2Seconds()
{
// Arrange
var sw = new Stopwatch();
sw.Start();
// Act
var result = _sut.Map <PersonModel>(SheetName, opt =>
opt
.ForMember(m => m.CustomRowNumber, Resolve.ByValue("Custom Identification No"))).ToList();
sw.Stop();
// Assert
Assert.Equal(1000, result.Count);
Assert.True(5000 > sw.ElapsedMilliseconds);
_output.WriteLine("{0} records loaded in {1} milliseconds.", result.Count, sw.ElapsedMilliseconds);
}
public void Should_not_call_chain_until_resolver_executed()
{
/* Given */
var values = new List <int>();
var builder = new ResolverBuilder();
builder.Use((context, next) =>
{
values.Add(0);
return(next(context));
});
builder.Run(context => new ValueTask <IResolverResult>(Resolve.As(42)));
/* When */
builder.Build();
/* Then */
Assert.Equal(new int[] {}, values.ToArray());
}
private static void CreateLogWriterPolicies(IPolicyList policyList,
IUnityContainer container,
LoggingSettings settings,
IConfigurationSource ConfigurationSource)
{
new PolicyBuilder <LogWriter, LoggingSettings>(
null,
settings,
c => new LogWriter(
Resolve.ReferenceCollection <List <ILogFilter>, ILogFilter>(from f in settings.LogFilters select f.Name),
Resolve.ReferenceCollection <List <LogSource>, LogSource>(from ts in settings.TraceSources select ts.Name),
Resolve.OptionalReference <LogSource>(AllTraceSourceKey),
Resolve.OptionalReference <LogSource>(NoMatchesTraceSourceKey),
Resolve.Reference <LogSource>(ErrorsTraceSourceKey),
settings.DefaultCategory,
settings.TracingEnabled,
settings.LogWarningWhenNoCategoriesMatch))
.AddPoliciesToPolicyList(policyList);
container.RegisterType(typeof(LogWriter), new ContainerControlledLifetimeManager());
}
private static void RegisterTypeFactories(string startPath)
{
IEnumerable <Assembly> extraAssemblies = LoadFromFiles(new DirectoryInfo(Path.GetDirectoryName(startPath)).GetFiles("*.dll"));
Resolve.RegisterTypeFactories(_workFolderPath, extraAssemblies);
RuntimeEnvironment.RegisterTypeFactories();
DesktopFactory.RegisterTypeFactories();
TypeMap.Register.New <IProtectedData>(() => new ProtectedDataImplementation(System.Security.Cryptography.DataProtectionScope.CurrentUser));
TypeMap.Register.New <ILauncher>(() => new Launcher());
TypeMap.Register.New <AxCryptHMACSHA1>(() => PortableFactory.AxCryptHMACSHA1());
TypeMap.Register.New <HMACSHA512>(() => new Mono.Cryptography.HMACSHA512Wrapper(new Axantum.AxCrypt.Desktop.Cryptography.HMACSHA512CryptoServiceProvider()));
TypeMap.Register.New <Aes>(() => new Axantum.AxCrypt.Mono.Cryptography.AesWrapper(new System.Security.Cryptography.AesCryptoServiceProvider()));
TypeMap.Register.New <Sha1>(() => PortableFactory.SHA1Managed());
TypeMap.Register.New <Sha256>(() => PortableFactory.SHA256Managed());
TypeMap.Register.New <CryptoStreamBase>(() => PortableFactory.CryptoStream());
TypeMap.Register.New <RandomNumberGenerator>(() => PortableFactory.RandomNumberGenerator());
TypeMap.Register.New <LogOnIdentity, IAccountService>((LogOnIdentity identity) => new CachingAccountService(new DeviceAccountService(new LocalAccountService(identity, Resolve.WorkFolder.FileInfo), new ApiAccountService(new AxCryptApiClient(identity.ToRestIdentity(), Resolve.UserSettings.RestApiBaseUrl, Resolve.UserSettings.ApiTimeout)))));
TypeMap.Register.New <GlobalApiClient>(() => new GlobalApiClient(Resolve.UserSettings.RestApiBaseUrl, Resolve.UserSettings.ApiTimeout));
TypeMap.Register.New <AxCryptApiClient>(() => new AxCryptApiClient(Resolve.KnownIdentities.DefaultEncryptionIdentity.ToRestIdentity(), Resolve.UserSettings.RestApiBaseUrl, Resolve.UserSettings.ApiTimeout));
TypeMap.Register.New <ISystemCryptoPolicy>(() => new ProCryptoPolicy());
TypeMap.Register.New <ICryptoPolicy>(() => New <LicensePolicy>().Capabilities.CryptoPolicy);
TypeMap.Register.Singleton <LicensePolicy>(() => new LicensePolicy());
TypeMap.Register.Singleton <FontLoader>(() => new FontLoader());
TypeMap.Register.Singleton <IEmailParser>(() => new EmailParser());
TypeMap.Register.Singleton <KeyPairService>(() => new KeyPairService(0, 0, New <UserSettings>().AsymmetricKeyBits));
TypeMap.Register.Singleton <ICache>(() => new ItemCache());
TypeMap.Register.Singleton <DummyReferencedType>(() => new DummyReferencedType());
TypeMap.Register.Singleton <AxCryptOnlineState>(() => new AxCryptOnlineState());
TypeMap.Register.Singleton <IVersion>(() => new DesktopVersion());
TypeMap.Register.Singleton <PasswordStrengthEvaluator>(() => new PasswordStrengthEvaluator(100, 8));
TypeMap.Register.Singleton <IKnownFoldersDiscovery>(() => new KnownFoldersDiscovery());
TypeMap.Register.Singleton <IBrowser>(() => new Browser());
TypeMap.Register.Singleton <ILicenseAuthority>(() => new PublicLicenseAuthority());
TypeMap.Register.Singleton <PremiumManager>(() => new PremiumManagerWithAutoTrial());
TypeMap.Register.Singleton <AboutAssembly>(() => new AboutAssembly(Assembly.GetExecutingAssembly()));
TypeMap.Register.Singleton <FileLocker>(() => new FileLocker());
TypeMap.Register.Singleton <IProgressDialog>(() => new ProgressDialog());
TypeMap.Register.Singleton <CultureNameMapper>(() => new CultureNameMapper(New <GlobalApiClient>().GetCultureInfoListAsync));
}
private static void InitializeTypeFactories()
{
RuntimeEnvironment.RegisterTypeFactories();
IEnumerable <Assembly> assemblies = LoadFromFiles(GetExecutingDirectory().GetFiles("*.dll"));
Resolve.RegisterTypeFactories(assemblies);
TypeMap.Register.Singleton <IEmailParser>(() => new RegexEmailParser());
TypeMap.Register.Singleton <ISettingsStore>(() => new TransientSettingsStore());
TypeMap.Register.Singleton <INow>(() => new Now());
TypeMap.Register.Singleton <IInternetState>(() => new AlwaysOnInternetState());
TypeMap.Register.New <RandomNumberGenerator>(() => PortableFactory.RandomNumberGenerator());
TypeMap.Register.New <AxCryptHMACSHA1>(() => PortableFactory.AxCryptHMACSHA1());
TypeMap.Register.New <HMACSHA512>(() => PortableFactory.HMACSHA512());
TypeMap.Register.New <Aes>(() => new Axantum.AxCrypt.Mono.Cryptography.AesWrapper(new System.Security.Cryptography.AesCryptoServiceProvider()));
TypeMap.Register.New <Sha1>(() => PortableFactory.SHA1Managed());
TypeMap.Register.New <Sha256>(() => PortableFactory.SHA256Managed());
TypeMap.Register.New <CryptoStreamBase>(() => PortableFactory.CryptoStream());
}
void IContainerPolicyCreator.CreatePolicies(
IPolicyList policyList,
string instanceName,
ConfigurationElement configurationObject,
IConfigurationSource configurationSource)
{
LoggingExceptionHandlerData castConfigurationObject = (LoggingExceptionHandlerData)configurationObject;
new PolicyBuilder <LoggingExceptionHandler, LoggingExceptionHandlerData>(
NamedTypeBuildKey.Make <LoggingExceptionHandler>(instanceName),
castConfigurationObject,
c => new LoggingExceptionHandler(
castConfigurationObject.LogCategory,
castConfigurationObject.EventId,
castConfigurationObject.Severity,
castConfigurationObject.Title,
castConfigurationObject.Priority,
castConfigurationObject.FormatterType,
Resolve.Reference <LogWriter>(null)))
.AddPoliciesToPolicyList(policyList);
}
public async Task AutoInjection_MockAndVerify()
{
// Given
var requestTracker = m_TeePeeBuilder.ForRequest("https://some.api/path/resource", HttpMethod.Put)
.ContainingQueryParam("filter", "other")
.WithBody(new { Caller = "ThisCaller" })
.Responds()
.WithStatus(HttpStatusCode.Created)
.TrackRequest();
var controller = Resolve.WithDefaultClient <HttpClientFactoryBasicUsageController>(m_TeePeeBuilder);
// When
var result = await controller.FireAndForget();
// Then
Assert.NotNull(result);
Assert.IsType <OkResult>(result);
requestTracker.WasCalled(1);
}
public async Task ShowUsingDevStorage()
{
var account = CloudStorageAccount.DevelopmentStorageAccount;
var client = account.CreateCloudTableClient();
var portfolioId = Guid.NewGuid();
await new ConnectedProjector <CloudTableClient>(Resolve.WhenEqualToHandlerMessageType(Projection.Handlers)).
ProjectAsync(client, new object[]
{
new RebuildProjection(),
new PortfolioAdded {
Id = portfolioId, Name = "My portfolio"
},
new PortfolioRenamed {
Id = portfolioId, Name = "Your portfolio"
},
new PortfolioRemoved {
Id = portfolioId
}
});
}
public async Task Show()
{
//Spin up a docker image of elastic search and/or change the endpoint below
var config = new ConnectionConfiguration(new Uri("http://192.168.99.100:32769/"));
var client = new ElasticsearchClient(config);
var portfolioId = Guid.NewGuid();
await new ConnectedProjector <ElasticsearchClient>(Resolve.WhenEqualToHandlerMessageType(Projection.Handlers)).
ProjectAsync(client, new object[]
{
new PortfolioAdded {
Id = portfolioId, Name = "My portfolio"
},
new PortfolioRenamed {
Id = portfolioId, Name = "Your portfolio"
},
new PortfolioRemoved {
Id = portfolioId
}
});
}
public void ByCountFirst()
{
// Arrange
#region inject_count_first_arrange
Container.RegisterType <SampleType>(Invoke.Constructor(Resolve.Parameter()));
#endregion
// Act
#region inject_count_first_ctor_act
var instance = Container.Resolve <SampleType>();
// 1 == instance.Ctor
#endregion
// Validate
Assert.AreEqual(1, instance.Ctor);
}
public async Task Show()
{
using (var cache = new MemoryCache(new Random().Next().ToString()))
{
var portfolioId = Guid.NewGuid();
await new Projector <MemoryCache>(
Resolve.WhenEqualToHandlerMessageType(Projection.Handlers)).
ProjectAsync(cache, new object[]
{
new PortfolioAdded {
Id = portfolioId, Name = "My portfolio"
},
new PortfolioRenamed {
Id = portfolioId, Name = "Your portfolio"
},
new PortfolioRemoved {
Id = portfolioId
}
});
}
}
static void Main(string[] args)
{
var projector = new SqlProjector(
Resolve.WhenEqualToHandlerMessageType(new OnHandInventoryViewProjection()),
new TransactionalSqlCommandExecutor(
SqlClientFactory.Instance,
@"Data Source=localhost;Initial Catalog=InventoryPOC;Integrated Security=SSPI;",
IsolationLevel.ReadCommitted));
projector.Project(new List <object> {
new DropSchema(), new CreateSchema()
});
var credentials = new UserCredentials("admin", "changeit");
var connectionSettings = ConnectionSettings.Create()
.KeepReconnecting()
.KeepRetrying()
.FailOnNoServerResponse()
.WithConnectionTimeoutOf(TimeSpan.FromSeconds(20))
.SetOperationTimeoutTo(TimeSpan.FromSeconds(10))
.SetHeartbeatInterval(TimeSpan.FromSeconds(10))
.SetHeartbeatTimeout(TimeSpan.FromSeconds(20));
using (var connection = EventStoreConnection.Create("ConnectTo=tcp://admin:[email protected]:1113; HeartBeatTimeout=5000", connectionSettings))
{
connection.ConnectAsync().GetAwaiter().GetResult();
var subscription = connection.SubscribeToStreamFrom("$ce-ledgerEntry", StreamPosition.Start, CatchUpSubscriptionSettings.Default, (_, @event) =>
{
projector.Project(
JsonConvert.DeserializeObject(
Encoding.UTF8.GetString(@event.Event.Data),
Assembly.GetAssembly(typeof(PortfolioRenamed)).GetType(@event.Event.EventType)));
}, userCredentials: credentials);
var a = subscription.LastProcessedEventNumber;
Console.ReadKey();
}
}
public void AppendMenuStyling(TagFormatter tag)
{
switch (tag.TagType)
{
case HTMLTagType.Title:
Menu.Title = tag.SpecialSetting;
return;
case HTMLTagType.WWidth:
if (int.TryParse(tag.SpecialSetting, out int width))
{
Menu.Width = width;
}
return;
case HTMLTagType.WHeight:
if (int.TryParse(tag.SpecialSetting, out int height))
{
Menu.Height = height;
}
return;
case HTMLTagType.WFColor:
if (Resolve.TryParseHTMLColor(tag.SpecialSetting, out var fcolor))
{
Menu.WFColor = fcolor;
}
return;
case HTMLTagType.WBColor:
if (Resolve.TryParseHTMLColor(tag.SpecialSetting, out var bcolor))
{
Menu.WBColor = bcolor;
}
return;
default:
return;
}
}
public void ProjectAsyncTokenMessagesSecondHandlerCancellationCausesExpectedResult()
{
Func <object, object, CancellationToken, Task> handler1 =
(connection, message, token) => Task.FromResult <object>(null);
Func <object, object, CancellationToken, Task> handler2 =
(connection, message, token) =>
{
var source = new TaskCompletionSource <object>();
source.SetCanceled();
return(source.Task);
};
ConnectedProjectionHandlerResolver <object> resolver = Resolve.WhenEqualToHandlerMessageType(new[]
{
new ConnectedProjectionHandler <object>(typeof(object), handler1),
new ConnectedProjectionHandler <object>(typeof(int), handler2)
});
var sut = SutFactory(resolver);
Assert.That(async() =>
await sut.ProjectAsync(new object(), new[] { new object(), new int() }, new CancellationToken()),
Throws.TypeOf <TaskCanceledException>());
}
public void ProjectAsyncMessageSecondHandlerFailureCausesExpectedResult()
{
Func <object, object, CancellationToken, Task> handler1 =
(connection, message, token) => Task.FromResult <object>(null);
Func <object, object, CancellationToken, Task> handler2 =
(connection, message, token) =>
{
var source = new TaskCompletionSource <object>();
source.SetException(new Exception("message"));
return(source.Task);
};
ConnectedProjectionHandlerResolver <object> resolver = Resolve.WhenEqualToHandlerMessageType(new[]
{
new ConnectedProjectionHandler <object>(typeof(object), handler1),
new ConnectedProjectionHandler <object>(typeof(int), handler2)
});
var sut = SutFactory(resolver);
Assert.That(async() =>
await sut.ProjectAsync(new object(), new int()),
Throws.TypeOf <AggregateException>().And.InnerException.TypeOf <Exception>().And.InnerException.Message.EqualTo("message"));
}
public async Task Title_gets_resolved_with_InternalName()
{
var ctx = new ClientObjectResolveContext(Context);
ctx.Include <Field>(
f => f.InternalName,
f => f.Description
);
Field = Resolve.Field().ById(HarshBuiltInFieldId.Title);
Binder.Bind(this, () => ctx);
await ctx.ProvisionerContext.ClientContext.ExecuteQueryAsync();
var field = Field.Value;
Assert.NotNull(field);
Assert.True(field.IsPropertyAvailable(f => f.Description));
Assert.True(field.IsPropertyAvailable(f => f.InternalName));
Assert.Equal("Title", field.InternalName);
}
/// <summary>
/// Decompile entire cartypeinfo block into Vector of separate elements.
/// </summary>
/// <param name="byteptr_t">Pointer to the beginning of cartypeinfo block in Global data.</param>
/// <param name="length">Length of the block to be read.</param>
/// <param name="db">Database to which add classes.</param>
private static unsafe void E_CarTypeInfo(byte *byteptr_t, uint length, Database.Carbon db)
{
uint size = 0xD0;
for (uint loop = 0; loop < length / size; ++loop)
{
uint offset = 8 + loop * size; // current offset of the cartypeinfo (padding included)
// Get CollectionName
string CName = ScriptX.NullTerminatedString(byteptr_t + offset, 0x10);
CName = Resolve.GetPathFromCollection(CName);
Map.BinKeys[Bin.Hash(CName)] = CName;
if (!LibColBlockExists)
{
Map.CollisionMap[Vlt.Hash(CName)] = CName;
}
var Class = new CarTypeInfo((IntPtr)(byteptr_t + offset), CName, db);
db.CarTypeInfos.Collections.Add(Class);
}
}
private static async Task WriteEvents(IEventStore eventStore, CancellationToken token)
{
var projections = new GetCurve.Projection().Handlers.Concat(new GetCurveList.Projection().Handlers).ToArray();
var projector = new Projector <InMemoryProjectionStore>(Resolve.WhenAssignableToHandlerMessageType(projections));
await foreach (var item in eventStore.Subscribe(token))
{
try
{
await projector.ProjectAsync(InMemoryProjectionStore.Instance, item, token);
var json = JsonSerializer.Serialize(item, RestMapper.Options);
Console.WriteLine();
Console.WriteLine(EventMapper.Name(item.Content.GetType()));
Console.WriteLine(json);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
public static CreateDirectiveVisitor AuthorizeVisitor(Func <int, ClaimsPrincipal> fetchUser)
{
return(builder => new DirectiveVisitor
{
FieldDefinition = (directive, fieldDefinition) =>
{
return fieldDefinition.WithResolver(resolver => resolver.Use((context, next) =>
{
var requiredRole = directive.GetArgument <string>("role");
var user = fetchUser(42);
if (!user.HasClaim("role", requiredRole))
{
return new ValueTask <IResolveResult>(Resolve.As("requires admin role. " +
"todo(pekka): should throw error or return error or??"));
}
return next(context);
}).Run(fieldDefinition.Resolver));
}
});
}
public async Task List_gets_resolved_by_url()
{
ClientContext.Load(Web, w => w.ServerRelativeUrl);
var list = await CreateList(l => l.RootFolder.ServerRelativeUrl);
var url = HarshUrl.GetRelativeTo(list.RootFolder.ServerRelativeUrl, Web.ServerRelativeUrl);
var results = ManualResolver.Resolve(
Resolve.List().ByUrl(url)
);
await ClientContext.ExecuteQueryAsync();
var resolvedList = Assert.Single(results);
Assert.NotNull(resolvedList);
Assert.Equal(
list.RootFolder.ServerRelativeUrl,
resolvedList.RootFolder.ServerRelativeUrl,
StringComparer.OrdinalIgnoreCase
);
}
public async Task AutoInjection_RecommendedPassiveMocking()
{
// Given
m_TeePeeBuilder.ForRequest("https://unittest.example.typed/path/resource", HttpMethod.Get)
.ContainingQueryParam("filter", "those")
.Responds()
.WithStatus(HttpStatusCode.OK)
.WithBody(new
{
Things = new[]
{
new
{
Value = 10
}
}
});
var controller = Resolve.WithTypedClient <HttpClientFactoryTypedUsageController, ExampleTypedHttpClient>(m_TeePeeBuilder,
sc =>
{
/* Example of using prod Setup code */
var configuration = UnitTestConfig.LoadUnitTestConfig();
// Call your production code, which sets up the Typed Client, here
sc.AddTypedHttpClients(configuration);
});
// When
var result = await controller.FireAndAct();
// Then
Assert.NotNull(result);
var okResult = Assert.IsType <OkObjectResult>(result);
var resultValue = Assert.IsType <int>(okResult.Value);
Assert.Equal(10, resultValue);
}
public Authority(MethodBase method)
{
this.m_Method = method;
if (method is DynamicMethod)
{
var _resolver = typeof(DynamicMethod).GetField("m_resolver", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(method);
if (_resolver == null)
{
throw new ArgumentException("The dynamic method's IL has not been finalized.");
}
this.m_TokenResolver = Delegate.CreateDelegate(typeof(Resolve), _resolver, _resolver.GetType().GetMethod("ResolveToken", BindingFlags.Instance | BindingFlags.NonPublic)) as Resolve;
this.m_StringResolver = Delegate.CreateDelegate(typeof(Func <int, string>), _resolver, _resolver.GetType().GetMethod("GetStringLiteral", BindingFlags.Instance | BindingFlags.NonPublic)) as Func <int, string>;
this.m_SignatureResolver = Delegate.CreateDelegate(typeof(Func <int, int, byte[]>), _resolver, _resolver.GetType().GetMethod("ResolveSignature", BindingFlags.Instance | BindingFlags.NonPublic)) as Func <int, int, byte[]>;
this.m_GetTypeFromHandleUnsafe = Delegate.CreateDelegate(typeof(GetTypeFromHandleUnsafe), typeof(Type).GetMethod("GetTypeFromHandleUnsafe", BindingFlags.Static | BindingFlags.NonPublic, null, new[] { typeof(IntPtr) }, null)) as GetTypeFromHandleUnsafe;
var _type = typeof(RuntimeTypeHandle).Assembly.GetType("System.RuntimeType");
var _method = typeof(RuntimeTypeHandle).Assembly.GetType("System.RuntimeMethodHandleInternal");
this.m_GetMethodBase = _type.GetMethod("GetMethodBase", BindingFlags.Static | BindingFlags.NonPublic, null, new[] { _type, _method }, null);
this.m_RuntimeMethodHandleInternalCtor = _method.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new[] { typeof(IntPtr) }, null);
var _stub = typeof(RuntimeTypeHandle).Assembly.GetType("System.RuntimeFieldInfoStub");
this.m_RuntimeFieldHandleStubCtor = _stub.GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, new[] { typeof(IntPtr), typeof(object) }, null);
this.m_GetFieldInfo = _type.GetMethod("GetFieldInfo", BindingFlags.Static | BindingFlags.NonPublic, null, new[] { _type, typeof(RuntimeTypeHandle).Assembly.GetType("System.IRuntimeFieldInfo") }, null);
}
}
public virtual void Resolve( Resolve Options
)
{
char UsageFlag = '-';
{
Resolve Dummy = new Resolve ();
Console.Write ("{0}resolve ", UsageFlag);
Console.Write ("[{0}] ", Dummy.Domain.Usage (null, "domain", UsageFlag));
Console.Write ("[{0}] ", Dummy.Service.Usage (null, "service", UsageFlag));
Console.Write ("[{0}] ", Dummy.Verbose.Usage ("verbose", "value", UsageFlag));
Console.WriteLine ();
}
Console.WriteLine (" {0}\t{1} = [{2}]", "String",
"Domain", Options.Domain);
Console.WriteLine (" {0}\t{1} = [{2}]", "String",
"Service", Options.Service);
Console.WriteLine (" {0}\t{1} = [{2}]", "String",
"Verbose", Options.Verbose);
Console.WriteLine ("Not Yet Implemented");
}
internal static Mastery GetMastery(this Obj_AI_Hero hero, Resolve resolve)
{
return FindMastery(hero, MasteryPage.Utility, (int)resolve);
}
public static Mastery GetMastery(this AIHeroClient hero, Resolve resolve)
{
return FindMastery(hero, MasteryPage.Resolve, (int) resolve);
}
public static Mastery GetResolve(this Obj_AI_Hero hero, Resolve resolve)
{
return hero.GetMastery(MasteryPage.Resolve, (int)resolve);
}
public static Mastery GetResolve(this AIHeroClient hero, Resolve resolve)
{
return hero.GetMastery(MasteryPage.Resolve, (int)resolve);
}
public static Mastery GetMastery(this Obj_AI_Hero hero, Resolve resolve)
{
return FindMastery(hero, MasteryPage.Resolve, (int)resolve);
}
private static void Usage()
{
Console.WriteLine ("Omnibroker Client");
Console.WriteLine ("");
{
Resolve Dummy = new Resolve ();
Console.Write ("{0}resolve ", UsageFlag);
Console.Write ("[{0}] ", Dummy.Domain.Usage (null, "domain", UsageFlag));
Console.Write ("[{0}] ", Dummy.Service.Usage (null, "service", UsageFlag));
Console.Write ("[{0}] ", Dummy.Verbose.Usage ("verbose", "value", UsageFlag));
Console.WriteLine ();
}
{
Bind Dummy = new Bind ();
Console.Write ("{0}bind ", UsageFlag);
Console.Write ("[{0}] ", Dummy.Account.Usage (null, "account", UsageFlag));
Console.Write ("[{0}] ", Dummy.PIN.Usage (null, "pin", UsageFlag));
Console.Write ("[{0}] ", Dummy.Server.Usage ("server", "value", UsageFlag));
Console.Write ("[{0}] ", Dummy.Port.Usage ("port", "value", UsageFlag));
Console.WriteLine ();
}
{
Unbind Dummy = new Unbind ();
Console.Write ("{0}unbind ", UsageFlag);
Console.WriteLine ();
}
}
public override void Resolve(Resolve Options)
{
base.Resolve(Options);
}
private static void Handle_Resolve(
OBPClient Dispatch, string[] args, int index)
{
Resolve Options = new Resolve ();
Registry Registry = new Registry ();
Options.Domain.Register ("domain", Registry, (int) TagType_Resolve.Domain);
Options.Service.Register ("service", Registry, (int) TagType_Resolve.Service);
Options.Verbose.Register ("verbose", Registry, (int) TagType_Resolve.Verbose);
// looking for parameter Param.Name}
if (index < args.Length && !IsFlag (args [index][0] )) {
// Have got the parameter, call the parameter value method
Options.Domain.Parameter (args [index]);
index++;
}
// looking for parameter Param.Name}
if (index < args.Length && !IsFlag (args [index][0] )) {
// Have got the parameter, call the parameter value method
Options.Service.Parameter (args [index]);
index++;
}
#pragma warning disable 162
for (int i = index; i< args.Length; i++) {
if (!IsFlag (args [i][0] )) {
throw new Exception ("Unexpected parameter: " + args[i]);}
string Rest = args [i].Substring (1);
TagType_Resolve TagType = (TagType_Resolve) Registry.Find (Rest);
// here have the cases for what to do with it.
switch (TagType) {
case TagType_Resolve.Verbose : {
int OptionParams = Options.Verbose.Tag (Rest);
if (OptionParams>0 && ((i+1) < args.Length)) {
if (!IsFlag (args [i+1][0] )) {
i++;
Options.Verbose.Parameter (args[i]);
}
}
break;
}
default : throw new Exception ("Internal error");
}
}
#pragma warning restore 162
Dispatch.Resolve (Options);
}
