public ShipsBundle()
{
Bomber = new Bomber();
Carrier = new Carrier();
Fighter = new Fighter();
Interceptor = new Interceptor();
Juggernaut = new Juggernaut();
Scout = new Scout();
}
public void Interceptor_AddInterceptorTwiceTest()
{
var collection = new InterceptorCollection();
var orig = new Interceptor<Order>();
collection.Add(orig);
var second = collection.Add(new Interceptor<Order>());
Assert.AreNotSame(orig, second);
}
public void Interceptor_AddInterceptorTest()
{
var collection = new InterceptorCollection();
var orig = new Interceptor<Order>();
collection.Add(orig);
var reference = collection.GetInterceptor<Order>();
Assert.AreSame(orig, reference);
}
public void DoNotIntercept()
{
CheckDispose();
if (Interceptor != null)
{
Interceptor.Dispose();
Interceptor = null;
}
*m_pInterceptCallback = IntPtr.Zero;
}
public void ProxyGenerator_CreateInterfaceProxyWithoutTarget_can_create_delegate_proxy_without_target()
{
var options = new ProxyGenerationOptions();
options.AddDelegateTypeMixin(typeof(Action));
var _ = new Interceptor();
var proxy = generator.CreateInterfaceProxyWithoutTarget(
typeof(IComparable),
options,
_
);
}
public static void Property()
{
var mock = Interceptor
.For <SomeUnmockableObject>()
.Setup(m => m.Dummy)
.Returns(4);
mock.As <IUnmockable <SomeUnmockableObject> >()
.Execute(m => m.Dummy);
mock.Verify();
}
public static async Task NoResultAsync()
{
var mock = Interceptor
.For <SomeUnmockableObject>()
.Setup(m => m.FooAsync());
await mock.As <IUnmockable <SomeUnmockableObject> >()
.Invoking(x => x.Execute(m => m.FooAsync()))
.Should()
.ThrowAsync <UninitializedException>()
.WithMessage("FooAsync()");
}
public static void NoResult()
{
var mock = Interceptor
.For <SomeUnmockableObject>()
.Setup(m => m.Foo());
mock.As <IUnmockable <SomeUnmockableObject> >()
.Invoking(x => x.Execute(m => m.Foo()))
.Should()
.Throw <UninitializedException>()
.WithMessage("Foo()");
}
public static void NoSetupEnumerable()
{
var items = new[] { 1, 2, 3, 4 };
Interceptor
.For <SomeUnmockableObject>()
.As <IUnmockable <SomeUnmockableObject> >()
.Invoking(x => x.Execute(m => m.Foo(items)))
.Should()
.Throw <SetupNotFoundException>()
.WithMessage("Foo([1, 2, 3, 4])");
}
public static void WithException()
{
var mock = Interceptor
.For <SomeUnmockableObject>()
.Setup(m => m.Foo(Arg.With <int>(x => x.Should().Be(3, ""))))
.Returns(5);
mock.As <IUnmockable <SomeUnmockableObject> >()
.Invoking(x => x.Execute(m => m.Foo(13)))
.Should()
.Throw <XunitException>();
}
protected override async Task OnInitializedAsync()
{
Interceptor.RegisterEvent();
noTextToDisplay = _localizer[LangKey.NO_DATA_TO_DISPLAY];
var result = await _apiWrapper.ExchangeSettings.GetAllAsync(TenantId, _search);
if (result.IsSuccess && result.Error == null)
{
_dataSource = result.Data;
}
}
/* Constructor */
public MainForm()
{
InitializeComponent();
// Create macro player
m_MacroPlayer = new MacroPlayer();
m_MacroPlayer.PropertyChanged += MacroPlayer_PropertyChanged;
// Set control mode
SetControlMode(ControlMode.Macro);
// Create save/load helper
m_SaveLoadHelper = new SaveLoadHelper(this, m_MacroPlayer);
m_SaveLoadHelper.PropertyChanged += SaveLoadHelper_PropertyChanged;
// Enable watchdog based on settings
if (!Program.Settings.AutoInject)
{
Interceptor.InjectionMode = InjectionMode.Compatibility;
}
// Attempt to inject into PS4 Remote Play
try
{
Interceptor.Inject();
}
// Injection failed
catch (InterceptorException ex)
{
// Only handle when PS4 Remote Play is in used by another injection
if (ex.InnerException != null && ex.InnerException.Message.Equals("STATUS_INTERNAL_ERROR: Unknown error in injected C++ completion routine. (Code: 15)"))
{
MessageBox.Show("The process has been injected by another executable. Restart PS4 Remote Play and try again.", "Injection Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
Environment.Exit(-1);
}
else
{
// Handle exception if watchdog is disabled
if (!Program.Settings.AutoInject)
{
MessageBox.Show(string.Format("[{0}] - {1}", ex.GetType().ToString(), ex.Message), "Injection Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
Environment.Exit(-1);
}
}
}
// Start watchdog to automatically inject when possible
if (Program.Settings.AutoInject)
{
Interceptor.Watchdog.Start();
}
}
/// <summary>
/// Register a component
/// </summary>
/// <param name="type"></param>
/// <param name="life"></param>
/// <param name="interceptor"></param>
/// <param name="keyedInterfaceType"></param>
public void RegisterComponent(Type type, LifeStyle life = LifeStyle.Singleton,
Interceptor interceptor = Interceptor.None)
{
var builder = new ContainerBuilder();
if (type.IsGenericType)
{
var registration = builder.RegisterGeneric(type).PropertiesAutowired().WithAttributeFiltering();
foreach (var interfaceType in type.GetInterfaces())
{
if (interfaceType.IsGenericType)
{
//registration = keyedInterfaceType != null && keyedInterfaceType==interfaceType.GetGenericTypeDefinition()
// ? registration.Keyed(keyedInterfaceType, interfaceType.GetGenericTypeDefinition()).PropertiesAutowired()
// : registration.As(interfaceType.GetGenericTypeDefinition()).PropertiesAutowired();
registration = registration.As(interfaceType.GetGenericTypeDefinition()).PropertiesAutowired().WithAttributeFiltering();
}
}
SetMeta(type, registration);
SetLifetimeScope(life, registration);
SetIntercepter(interceptor, registration);
}
else
{
var registration = builder.RegisterType(type).PropertiesAutowired().WithAttributeFiltering();
var interfaceTypes = type.GetInterfaces();
if (interfaceTypes.Any())
{
foreach (var interfaceType in type.GetInterfaces())
{
//registration = keyedInterfaceType != null&& keyedInterfaceType == interfaceType
// ? registration.Keyed(keyedInterfaceType, interfaceType).PropertiesAutowired()
// : registration.As(interfaceType).PropertiesAutowired();
registration = registration.As(interfaceType).PropertiesAutowired().WithAttributeFiltering();
}
}
else
{
registration = builder.RegisterType(type).PropertiesAutowired().AsSelf();
}
SetMeta(type, registration);
SetLifetimeScope(life, registration);
SetIntercepter(interceptor, registration);
}
builder.Update(Container);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="port"></param>
/// <param name="logger"></param>
public PluginServiceServer(int port, ILogger logger)
{
Port = port;
Logger = logger;
Interceptor = new PluginGrpcInterceptor(Logger);
m_server = new Server(GrpcPluginSettings.GetChannelOptions())
{
Services = { PluginService.BindService(this).Intercept(Interceptor) },
Ports = { new ServerPort(IPAddress.Loopback.ToString(), Port, ServerCredentials.Insecure) },
};
}
public void Release(Interceptor interceptor)
{
if (interceptor == null)
{
throw new ArgumentNullException(nameof(interceptor));
}
if (interceptor is IDisposable disposableInterceptor && _createdInterceptors != null && _createdInterceptors.Contains(interceptor))
{
_createdInterceptors.Remove(interceptor);
disposableInterceptor.Dispose();
}
}
private void StartReaderLoop()
{
var thread = new Thread(() =>
{
while (!Disconnected)
{
var buf = ReadNextPacket(out int packetId);
Interceptor?.OnClientPacket(packetId, buf);
}
});
thread.Start();
}
private void StartIntercepting()
{
this.intercepting = true;
var cryptoHandler = new PassiveCryptoHandler();
cryptoHandler.WorkingKeyDefined += this.OnWorkingKeyDefined;
var virtualDevice = new DecryptedDevice(cryptoHandler, new SerialDevice(this.UxComboVirtualCom.Text));
var realDevice = new DecryptedDevice(cryptoHandler, new SerialDevice(this.UxComboRealCom.Text));
this.interceptor = new Interceptor(virtualDevice, realDevice);
this.interceptor.Request += this.OnRequest;
this.interceptor.Response += this.OnResponse;
}
public static void MultipleNotExecuted()
{
var mock = Interceptor
.For <SomeUnmockableObject>()
.Setup(m => m.Foo())
.Returns(3)
.Then(4);
mock.Invoking(x => x.Verify())
.Should()
.Throw <NotExecutedException>()
.WithMessage("Foo(): 3, 4");
}
public void When_using_CreateInterfaceProxyWithTargetInterface_Invocation_TargetType_is_equal_to_type_of_target()
{
var interceptor = new Interceptor();
var proxy = generator.CreateInterfaceProxyWithTargetInterface <IFoo>(
new FooTarget(),
interceptor
);
proxy.Method();
Assert.AreEqual(typeof(FooTarget), interceptor.ReceivedTargetType);
}
public static void IgnoreArgument()
{
var mock = Interceptor
.For <SomeUnmockableObject>()
.Setup(m => m.Foo(Arg.Ignore <int>()))
.Returns(5);
mock.As <IUnmockable <SomeUnmockableObject> >()
.Execute(x => x.Foo(13))
.Should()
.Be(5);
mock.Verify();
}
public static void NullArgument()
{
var mock = Interceptor
.For <SomeUnmockableObject>()
.Setup(m => m.Foo(3, null))
.Returns(5);
mock.As <IUnmockable <SomeUnmockableObject> >()
.Execute(x => x.Foo(3, null))
.Should()
.Be(5);
mock.Verify();
}
internal DirectoryServiceFailOnSearch(LdapAuthIT outerInstance)
{
this._outerInstance = outerInstance;
FailOnSearchInterceptor = new BaseInterceptorAnonymousInnerClass(this);
try
{
Service.addFirst(FailOnSearchInterceptor);
}
catch (LdapException e)
{
throw new Exception(e);
}
}
internal DirectoryServiceWaitOnSearch(LdapAuthIT outerInstance, long waitingTimeMillis)
{
this._outerInstance = outerInstance;
WaitOnSearchInterceptor = new BaseInterceptorAnonymousInnerClass(this, waitingTimeMillis);
try
{
Service.addFirst(WaitOnSearchInterceptor);
}
catch (LdapException e)
{
throw new Exception(e);
}
}
public void interceptors_should_not_be_executed_if_instance_is_chached()
{
var interceptor = new Interceptor();
var container = new Container(x => x.For<object>().Use<object>()
.Intercept(interceptor)
.Lifetime.Singleton());
interceptor.ExecuteCount.Should().Be(0);
container.Get<object>();
interceptor.ExecuteCount.Should().Be(1);
container.Get<object>();
interceptor.ExecuteCount.Should().Be(1);
}
private static void InitialFactories()
{
var policy = new InterceptionBehavior <PolicyInjectionBehavior>();
var intercptor = new Interceptor <TransparentProxyInterceptor>();
var type = typeof(ServiceFactory);
Container.Current.RegisterType(
typeof(IServiceFactory),
type,
new ContainerControlledLifetimeManager(),
policy,
intercptor
);
}
public static async Task FuncAsyncThrows()
{
var mock = Interceptor
.For <SomeUnmockableObject>()
.Setup(x => x.FooAsync())
.Throws <FileNotFoundException>();
await mock.As <IUnmockable <SomeUnmockableObject> >()
.Invoking(x => x.Execute(m => m.FooAsync()))
.Should()
.ThrowAsync <FileNotFoundException>();
mock.Verify();
}
public static void With()
{
var mock = Interceptor
.For <SomeUnmockableObject>()
.Setup(m => m.Foo(Arg.With <int>(x => x.Should().Be(3, "that's what it's always been"))))
.Returns(5);
mock.As <IUnmockable <SomeUnmockableObject> >()
.Execute(x => x.Foo(3))
.Should()
.Be(5);
mock.Verify();
}
/// <summary>
/// Creates a new object instance according to the lifetime manager's properties.
/// If the target type is decorated with the <see cref="InterceptedAttribute"/>,
/// it is automatically intercepted.
/// </summary>
/// <returns></returns>
protected virtual object CreateObjectInstance()
{
var instance = ConfigurationHelper.CreateInstance(
ServiceObjectType,
ConstructionParameters,
Properties);
if (ServiceObjectType.GetCustomAttributes(typeof(InterceptedAttribute), true).Length > 0 &&
ServiceObjectType.GetCustomAttributes(typeof(DisableInterceptionAttribute), false).Length == 0)
{
// --- This is an intercepted object
instance = Interceptor.GetInterceptedObject(ServiceType, instance, null);
}
return(instance);
}
/// <summary>
/// Detach from the logging event source.
/// Implicitly take a snapshot.
/// </summary>
public void Detach()
{
if (_appender == null)
{
throw new InvalidOperationException("Not attached");
}
// RemoveAppender throws an exception if the appender
// to be removed is not in the list of appenders!
Interceptor.RemoveAppender(_appender);
TakeSnapshot();
_appender = null;
}
public static void Execute()
{
var args = new Stack <int>();
Interceptor
.For <SomeUnmockableObject>()
.Setup(y => y.Foo(Arg.With <int>(x => args.Push(x))))
.Returns(3)
.Execute(y => y.Foo(3))
.Should()
.Be(3);
args.Should()
.BeEquivalentTo(3);
}
public static void ActionThrows()
{
var mock = Interceptor
.For <SomeUnmockableObject>()
.Setup(m => m.Bar(5))
.Throws <FileNotFoundException>();
mock
.As <IUnmockable <SomeUnmockableObject> >()
.Invoking(x => x.Execute(m => m.Bar(5)))
.Should()
.Throw <FileNotFoundException>();
mock.Verify();
}
public static IUnityContainer RegisterComponents()
{
var container = new UnityContainer();
container.AddNewExtension <Interception>();
var interceptor = new Interceptor <InterfaceInterceptor>();
var behaver = new InterceptionBehavior <LoggingInterceptionBehavior>();
container.RegisterType <DbContext, DatabaseContext>(new HierarchicalLifetimeManager());
container.RegisterType(typeof(IRepository <>), typeof(EfRepository <>));
return(container);
}
public static void MoreInvocationsOnSingleResult()
{
var mock = Interceptor
.For <SomeUnmockableObject>()
.Setup(m => m.Foo())
.Returns(3);
var sut = mock.As <IUnmockable <SomeUnmockableObject> >();
sut.Execute(m => m.Foo())
.Should().Be(3);
sut.Execute(m => m.Foo())
.Should().Be(3);
}
public void ProxyGenerator_CreateInterfaceProxyWithoutTarget_cannot_proceed_to_delegate_type_mixin()
{
var options = new ProxyGenerationOptions();
options.AddDelegateTypeMixin(typeof(Action));
var interceptor = new Interceptor(shouldProceed: true);
var proxy = generator.CreateInterfaceProxyWithoutTarget(typeof(IComparable), options, interceptor);
var action = ProxyUtil.CreateDelegateToMixin <Action>(proxy);
Assert.NotNull(action);
Assert.Throws <NotImplementedException>(() => action.Invoke());
}
public static void Main(string[] args)
{
var interceptor = new Interceptor();
interceptor.Register<Person>();
var person = interceptor.Resolve<Person>();
//var person = new Person();
person.FirstName = "Bill";
person.LastName = "Gates";
person.Introduce();
Console.ReadKey();
}
public void configured_interceptors_and_lifetimes_should_be_cloned_and_clone_should_be_executed()
{
var lifetime = new Lifetime();
var interceptor = new Interceptor();
new Container(x => x.For(typeof(IList<>)).Use(typeof(List<>))
.Lifetime.Use(lifetime)
.Intercept(interceptor))
.Get<IList<int>>();
lifetime.IsCloned.Should().BeTrue();
lifetime.Executed.Should().BeFalse();
lifetime.Clone.IsCloned.Should().BeFalse();
lifetime.Clone.Executed.Should().BeTrue();
interceptor.IsCloned.Should().BeTrue();
interceptor.Executed.Should().BeFalse();
interceptor.Clone.IsCloned.Should().BeFalse();
interceptor.Clone.Executed.Should().BeTrue();
}
public void PressKey(Interceptor.Keys key)
{
}
internal Interceptor SetSuccessor(Interceptor successor)
{
_successor = successor;
return this;
}
internal InterceptionFlow(Interceptor[] interceptors) {
m_increment = 1;
m_interceptors = interceptors;
ResetToStart();
}
internal RequestInterceptionFlow(Interceptor[] interceptors) : base(interceptors) {
}
/// <summary>
/// Creates the interceptor.
/// </summary>
/// <param name="interceptor">The interceptor delegate</param>
public DelegateInterceptor(Interceptor interceptor)
{
this.interceptor = interceptor;
}
/// <summary>
/// Constructs a connection handler for the given client.
/// </summary>
/// <param name="client">client connection</param>
/// <param name="interceptor">a request/reply interceptor, or null if none is required</param>
public ClientConnectionHandler(TcpClient client, Interceptor interceptor)
{
this.tcpClient = client;
this.interceptor = interceptor;
ContinueConnection = true;
}
/// <summary>
/// Create a socket listener. Listens for incoming connection
/// attempts. Accepts connections and creates an RpcConnectionHandler
/// to process requests from that connection.
/// </summary>
/// <param name="listenPort"></param>
/// <param name="interceptor"></param>
public SocketListener(int listenPort, Interceptor interceptor)
{
this.listenPort = listenPort;
this.interceptor = interceptor;
}
public static bool RemoveInterceptor(Interceptor interceptor)
{
return mInterceptors.Remove(interceptor);
}
public static bool AddInterceptor(Interceptor interceptor)
{
return mInterceptors.Add(interceptor);
}
public void ReleaseKey(Interceptor.Keys key)
{
}
public void Test_Interceptor()
{
ClearAll();
var dispatcher = new CountingMockMainThreadDispatcher();
Ioc.RegisterSingleton<IMvxMainThreadDispatcher>(dispatcher);
var interceptor = new Interceptor();
Ioc.RegisterSingleton<IMvxInpcInterceptor>(interceptor);
var notified = new List<string>();
var t = new TestInpc();
t.PropertyChanged += (sender, args) => notified.Add(args.PropertyName);
interceptor.Handler = (s, e) => MvxInpcInterceptionResult.RaisePropertyChanged;
t.RaisePropertyChanged(new PropertyChangedEventArgs("Foo"));
Assert.That(dispatcher.Count == 1);
interceptor.Handler = (s, e) => MvxInpcInterceptionResult.DoNotRaisePropertyChanged;
t.RaisePropertyChanged(new PropertyChangedEventArgs("Foo"));
Assert.That(dispatcher.Count == 1);
interceptor.Handler = (s, e) => MvxInpcInterceptionResult.RaisePropertyChanged;
t.RaisePropertyChanged(new PropertyChangedEventArgs("Foo"));
Assert.That(dispatcher.Count == 2);
}
IInterceptor IInterceptor.Clone()
{
Clone = new Interceptor();
return Clone;
}
