public void A_Init()
{
_stub = new StubBuilder();
_analyzationPreparer = new ReactionAnalyzationPreparer();
_sut = new RaiseReactionAnalyzer();
_raiseSizes = ApplicationProperties.RaiseSizeKeys;
}
public void _Init()
{
_stub = new StubBuilder();
_statisticMock = new Mock <IActionSequenceStatistic>();
_playerMock = new Mock <IAnalyzablePokerPlayer>();
_calculatorMock = new Mock <IPercentagesCalculator>();
}
private void button1_Click(object sender, EventArgs e)
{
InstallationPath path;
switch (cbPath.SelectedIndex)
{
case 0:
path = InstallationPath.Default;
break;
case 1:
path = InstallationPath.AppData;
break;
case 2:
path = InstallationPath.ProgramFiles;
break;
default:
path = InstallationPath.Default;
break;
}
var settings = new BuildSettings(txtHostname.Text, (int)numPort.Value, txtFilename.Text, path,
(int)numDelay.Value, cbMerge.Checked);
var builder = new StubBuilder(settings);
using (var ofd = new SaveFileDialog())
{
ofd.Filter = "Executable (*.exe)|*.exe";
if (ofd.ShowDialog() == DialogResult.OK)
{
builder.Build(ofd.FileName);
}
}
}
public void _Init()
{
_stub = new StubBuilder();
_convertedPlayerMake = new Constructor <IConvertedPokerPlayer>(() => new ConvertedPokerPlayer());
_container = new UnityContainer();
_container
.RegisterConstructor <IConvertedPokerAction, ConvertedPokerAction>()
.RegisterConstructor <IConvertedPokerActionWithId, ConvertedPokerActionWithId>()
.RegisterConstructor <IConvertedPokerRound, ConvertedPokerRound>()
.RegisterType <IPokerActionConverter, PokerActionConverter>()
.RegisterType <IPokerRoundsConverter, MockPokerRoundsConverter>();
_converter = (MockPokerRoundsConverter)_container.Resolve <IPokerRoundsConverter>();
_converter
.InitializeWith(
_stub.Setup <IAquiredPokerHand>()
.Get(hand => hand.TotalPot).Returns(_stub.Valid(For.TotalPot, 1.0)).Out,
_stub.Out <IConvertedPokerHand>(),
_stub.Valid(For.Pot, 1.0),
_stub.Out <double>(For.ToCall));
}
static Mock <IPokerHandParser> ParserThatRecognizesAndSeparatesHandsAndParseSetsAquiredHandTo(ulong gameId)
{
const string extractedHistory = "someHistory";
const int extractedGameId = 1;
var extractedHistories = new Dictionary <ulong, string> {
{ extractedGameId, extractedHistory }
};
Mock <IPokerHandParser> stubParser =
ParserThatRecognizesHandsAndWhenExtractingHandsReturns(extractedHistories, SomeHandHistoriesString);
var stub = new StubBuilder();
IAquiredPokerHand stubAquiredHand = stub.Setup <IAquiredPokerHand>()
.Get(p => p.GameId)
.Returns(gameId).Out;
stubParser
.Setup(p => p.AquiredPokerHand)
.Returns(stubAquiredHand);
stubParser
.Setup(p => p.IsValid)
.Returns(true);
stubParser
.Setup(p => p.ParseHand(It.IsAny <string>()))
.Returns(stubParser.Object);
return(stubParser);
}
public void _Init()
{
_stub = new StubBuilder();
_mockUserConfiguration = new MockUserConfiguration();
_mockSettings = new Settings(_mockUserConfiguration);
_mySqlProvider = new MySqlInfo();
_sqLiteProvider = new SqLiteInfo();
}
public void MethodGroupIsUnambiguousForEachExtensionMethod()
{
IAppBuilder app = new StubBuilder();
app.UseFilter((Action<OwinRequest>)OnFilter1);
app.UseFilterAsync(OnFilter2);
app.UseHandler((Action<OwinRequest, OwinResponse>)OnHandler1);
app.UseHandlerAsync(OnHandler2);
app.UseHandlerAsync(OnHandler3);
}
internal static void AssertCompile(Type type)
{
Program.GenerateImplementations(InterfaceCompileTests.ThisAssembly, type.Name);
var writer = new CSharpSourceWriter();
var fileName = new StubBuilder(writer).GetDesiredOutputFileName(type);
AssertCompile(fileName);
}
public void _Init()
{
_stub = new StubBuilder();
_container = new UnityContainer()
.RegisterType <IEventAggregator, EventAggregator>()
.RegisterInstance(_stub.Out <IDatabaseSettings>())
.RegisterInstance(_stub.Out <IDataProvider>())
.RegisterInstance(_stub.Out <IDatabaseConnector>());
}
public void AnonymousLambdaIsUnambiguousForEachExtensionMethod()
{
IAppBuilder app = new StubBuilder();
app.UseFilter(request => { });
app.UseFilter(async request => { await Task.Delay(0); });
app.UseHandler((request, response) => { });
app.UseHandler(async (request, response) => { await Task.Delay(0); });
app.UseHandler(async (request, response, next) => { await next(); });
}
internal static IPlayerStatistics PlayerStatisticsStubFor(string name)
{
var stub = new StubBuilder();
var playerIdentityStub = stub.Setup <IPlayerIdentity>()
.Get(pi => pi.Name).Returns(name).Out;
return(stub.Setup <IPlayerStatistics>()
.Get(ps => ps.PlayerIdentity).Returns(playerIdentityStub).Out);
}
public void MethodGroupIsUnambiguousForEachExtensionMethod()
{
IAppBuilder app = new StubBuilder();
app.UseFilter((Action <OwinRequest>)OnFilter1);
app.UseFilterAsync(OnFilter2);
app.UseHandler((Action <OwinRequest, OwinResponse>)OnHandler1);
app.UseHandlerAsync(OnHandler2);
app.UseHandlerAsync(OnHandler3);
}
public void AnonymousLambdaIsUnambiguousForEachExtensionMethod()
{
IAppBuilder app = new StubBuilder();
app.UseFilter(request => { });
app.UseFilter(async request => { await Task.Delay(0); });
app.UseHandler((request, response) => { });
app.UseHandler(async(request, response) => { await Task.Delay(0); });
app.UseHandler(async(request, response, next) => { await next(); });
}
public void _Init()
{
_stub = new StubBuilder();
_playerStatisticsViewModelMakeStub = new Mock <IConstructor <IPlayerStatisticsViewModel> >();
_playerStatisticsViewModelMakeStub
.SetupGet(make => make.New)
.Returns(_stub.Out <IPlayerStatisticsViewModel>);
_sut = new PokerTableStatisticsViewModelTester(_playerStatisticsViewModelMakeStub.Object);
}
public void WithId()
{
// Act
var stub = StubBuilder.Begin()
.WithId("stub-id")
.Build();
// Assert
Assert.AreEqual("stub-id", stub.Id);
}
public void WithConditionsAsBuilder()
{
// Act
var stub = StubBuilder.Begin()
.WithConditions(StubConditionBuilder.Begin())
.Build();
// Assert
Assert.IsNotNull(stub.Conditions);
}
public void IsDisabled()
{
// Act
var stub = StubBuilder.Begin()
.IsDisabled()
.Build();
// Assert
Assert.IsFalse(stub.Enabled);
}
public void WithTenant()
{
// Act
var stub = StubBuilder.Begin()
.WithTenant("tenant1")
.Build();
// Assert
Assert.AreEqual("tenant1", stub.Tenant);
}
public void WithDescription()
{
// Act
var stub = StubBuilder.Begin()
.WithDescription("stub description")
.Build();
// Assert
Assert.AreEqual("stub description", stub.Description);
}
public void WithPriorityAsPriorityType()
{
// Act
var stub = StubBuilder.Begin()
.WithPriority(PriorityType.High)
.Build();
// Assert
Assert.AreEqual(10, stub.Priority);
}
public void WithPriorityAsInt()
{
// Act
var stub = StubBuilder.Begin()
.WithPriority(1)
.Build();
// Assert
Assert.AreEqual(1, stub.Priority);
}
public void WithResponseAsBuilder()
{
// Act
var stub = StubBuilder.Begin()
.WithResponse(StubResponseBuilder.Begin())
.Build();
// Assert
Assert.IsNotNull(stub.Response);
}
public void InScenario()
{
// Act
const string scenario = "scenario-1";
var stub = StubBuilder.Begin()
.InScenario(scenario)
.Build();
// Assert
Assert.AreEqual(scenario, stub.Scenario);
}
public void WithResponseAsDto()
{
// Act
var response = new StubResponseDto();
var stub = StubBuilder.Begin()
.WithResponse(response)
.Build();
// Assert
Assert.AreEqual(response, stub.Response);
}
public void WithConditionsAsDto()
{
// Act
var conditions = new StubConditionsDto();
var stub = StubBuilder.Begin()
.WithConditions(conditions)
.Build();
// Assert
Assert.AreEqual(conditions, stub.Conditions);
}
/// <summary>
/// Gets a set of filter rules for registry access.
/// </summary>
private RegistryFilter GetRegistryFilter()
{
var filterRuleList = new LinkedList <RegistryFilterRule>();
if (_mainImplementation != null)
{
// Create one substitution stub for each command
foreach (var command in _mainImplementation.Commands)
{
// Only handle simple commands (executable path, no arguments)
if (string.IsNullOrEmpty(command.Path) || command.Arguments.Count != 0)
{
continue;
}
string processCommandLine = Path.Combine(_implementationDir, command.Path);
string registryCommandLine;
try
{ // Try to use a machine-wide stub if possible
registryCommandLine = StubBuilder.GetRunStub(_target, command.Name, _handler, machineWide: true);
}
catch (UnauthorizedAccessException)
{ // Fall back to per-user stub
registryCommandLine = StubBuilder.GetRunStub(_target, command.Name, _handler);
}
// Apply filter with normal and with escaped string
filterRuleList.AddLast(new RegistryFilterRule(processCommandLine, registryCommandLine));
filterRuleList.AddLast(new RegistryFilterRule("\"" + processCommandLine + "\"", "\"" + registryCommandLine + "\""));
}
}
// Redirect Windows SPAD commands to Zero Install
foreach (var defaultProgram in _target.Feed.CapabilityLists.CompatibleCapabilities().OfType <Store.Model.Capabilities.DefaultProgram>())
{
if (!string.IsNullOrEmpty(defaultProgram.InstallCommands.Reinstall))
{
filterRuleList.AddLast(GetInstallCommandFilter(defaultProgram.InstallCommands.Reinstall, defaultProgram.InstallCommands.ReinstallArgs, "--machine --batch --add=defaults " + _target.Uri.ToStringRfc().EscapeArgument()));
}
if (!string.IsNullOrEmpty(defaultProgram.InstallCommands.ShowIcons))
{
filterRuleList.AddLast(GetInstallCommandFilter(defaultProgram.InstallCommands.ShowIcons, defaultProgram.InstallCommands.ShowIconsArgs, "--machine --batch --add=icons " + _target.Uri.ToStringRfc().EscapeArgument()));
}
if (!string.IsNullOrEmpty(defaultProgram.InstallCommands.HideIcons))
{
filterRuleList.AddLast(GetInstallCommandFilter(defaultProgram.InstallCommands.HideIcons, defaultProgram.InstallCommands.HideIconsArgs, "--machine --batch --remove=icons " + _target.Uri.ToStringRfc().EscapeArgument()));
}
}
return(new RegistryFilter(filterRuleList));
}
public void A_Init()
{
var stub = new StubBuilder();
var valuedHoleCards1 = stub.Setup <IValuedHoleCards>()
.Get(vhc => vhc.ChenValue).Returns(1)
.Get(vhc => vhc.SklanskyMalmuthGrouping).Returns(1).Out;
var valuedHoleCards2 = stub.Setup <IValuedHoleCards>()
.Get(vhc => vhc.ChenValue).Returns(2)
.Get(vhc => vhc.SklanskyMalmuthGrouping).Returns(3).Out;
_sut = new ValuedHoleCardsAverage();
_sut.InitializeWith(new [] { valuedHoleCards1, valuedHoleCards2 });
}
public void _Init()
{
_sut = new StatisticsSetSummaryViewModel();
_stub = new StubBuilder();
_statisticsSetStub = new Mock <IActionSequenceStatisticsSet>();
_cumulativePercentages = new[] { 1, 2, 3, 4, 5 };
_statisticsSetStub
.SetupGet(ss => ss.CumulativePercentagesByRow)
.Returns(_cumulativePercentages);
_actionSequenceStatisticStub = _stub.Setup <IActionSequenceStatistic>()
.Get(s => s._actionSequence).Returns(ActionSequences.HeroB).Out;
}
public void _Init()
{
_stub = new StubBuilder();
_preFlopStatisticsViewModelStub = _stub.Out <IDetailedPreFlopStatisticsViewModel>();
_postFlopActionStatisticsViewModelStub = _stub.Out <IDetailedPostFlopHeroActsStatisticsViewModel>();
_postFlopReactionStatisticsViewModelStub = _stub.Out <IDetailedPostFlopHeroReactsStatisticsViewModel>();
_repositoryBrowserVM_Mock = new Mock <IRepositoryHandBrowserViewModel>();
_sut =
new DetailedStatisticsAnalyzerViewModel(
new Constructor <IDetailedPreFlopStatisticsViewModel>(() => _preFlopStatisticsViewModelStub),
new Constructor <IDetailedPostFlopHeroActsStatisticsViewModel>(() => _postFlopActionStatisticsViewModelStub),
new Constructor <IDetailedPostFlopHeroReactsStatisticsViewModel>(() => _postFlopReactionStatisticsViewModelStub), _repositoryBrowserVM_Mock.Object);
}
public void _Init()
{
_stub = new StubBuilder();
_eventAggregator = new EventAggregator();
_repositoryMock = new Mock <IRepository>();
_playerIdentityStub = _stub.Setup <IPlayerIdentity>()
.Get(pi => pi.Id).Returns(Id)
.Out;
_sut = new PlayerStatisticsSut(_eventAggregator, _repositoryMock.Object);
_sut.InitializePlayer(Name, Site);
}
internal static DecapsulatedConvertedPlayer InitializeConvertedPokerPlayerWithSomeValidValues()
{
const string someCards = "As Ks";
var stub = new StubBuilder();
return
((DecapsulatedConvertedPlayer) new DecapsulatedConvertedPlayer()
.InitializeWith(
"someName",
stub.Some(2.0),
stub.Some(1.0),
stub.Some(1),
stub.Some(4),
someCards));
}
public async Task UpdateStubAsync_Builder_ShouldUpdateStub()
{
// Arrange
const string stubId = "stub-id";
var client = new HttPlaceholderClient(CreateHttpClient(mock => mock
.When(HttpMethod.Put, $"{BaseUrl}ph-api/stubs/{stubId}")
.WithPartialContent("OK my dude!")
.Respond(HttpStatusCode.NoContent)));
var input = StubBuilder.Begin()
.WithResponse(StubResponseBuilder.Begin().WithTextResponseBody("OK my dude!"));
// Act / Assert
await client.UpdateStubAsync(input, "stub-id");
}
