public static Result <(int X, int Y)> TryGetPosition(this WorldObject obj)
{
Result <(int X, int Y)> result = Result <(int, int)> .CreateResult(false, (0, 0), "Obj has no [X,Y] Position");
if (obj.Tags != null && obj.Tags.Count > 1)
{
if (obj.Tags[0] is int x && obj.Tags[1] is int y)
{
result = Result <(int, int)> .CreateResult(true, (x, y));
}
}
return(result);
}
public ResponseMessage <object> TeacherTestTrans_D()
{
dynamic result;
var teacher = new T_Teacher()
{
F_TeacherName = $"Test_{ (DateTime.Now.Ticks - 621356256000000000) / 10000}"
};
var bl = _SqlDB.ExecuteWithTransaction((conn, trans) =>
{
var r = conn.Execute($"INSERT INTO T_Teacher (F_TeacherName) VALUES(@F_TeacherName);", teacher, trans, null, null);
r += conn.Execute("delete from T_Teacher where f_id=@id", new { id = 1 }, trans, null, null);
return(r);
});
if (bl)
{
result = CreateResult.For();
}
else
{
result = CreateResult.For("00001", "新增出现错误");
}
return(result);
}
public async Task <CreateResult> CreateProjectAsync(string name, string description, bool isPrivate)
{
var user = await _storage.GetUserAsync();
if (user == null)
{
throw new UnauthorizedAccessException(Strings.NotLoginYet);
}
var result = new CreateResult();
try
{
var repo = await user.Session.CreateRepoAsync(name, description, isPrivate);
result.Project = new Project()
{
Repo = repo
};
return(result);
}
catch (WebException ex)
{
OutputWindowHelper.ExceptionWriteLine($"LoginAsync:{ex.Message}", ex);
var res = (HttpWebResponse)ex.Response;
var statusCode = (int)res.StatusCode;
throw new Exception($"错误代码: {statusCode}");
}
}
public async void CreateAsyncTest()
{
CreateResult result = null;
var identifier = System.Guid.NewGuid().ToString();
try
{
var creation_group_result = await ApiReference.Instance.LargePersonGroup.CreateAsync(identifier, identifier, identifier);
if (creation_group_result)
{
result = await ApiReference.Instance.LargePersonGroupPerson.CreateAsync(identifier, identifier, identifier);
}
}
catch
{
throw;
}
finally
{
var deletion_person_result = await ApiReference.Instance.LargePersonGroupPerson.DeleteAsync(identifier, result.personId);
var deletion_group_result = await ApiReference.Instance.LargePersonGroup.DeleteAsync(identifier);
}
Assert.True(result != null);
}
public ResponseMessage <IEnumerable <UserInfo> > Get(int pageIndex, int pageSize)
{
int total = 0;
var result = _us.FindList(e => true, o => o.Id, out total, true, pageIndex, pageSize);
return(CreateResult.For(result, total));
}
/// <summary>
/// Iterates over the populated Dictionary object and pushes each attachment to the respective user story
/// </summary>
/// <param name="attachmentsDictionary"></param>
/// <param name="attachmentContent"></param>
/// <param name="attachmentContainer"></param>
/// <param name="createUserStory"></param>
private void PushAttachments(Dictionary <string, string> attachmentsDictionary, DynamicJsonObject attachmentContent, DynamicJsonObject attachmentContainer, CreateResult createUserStory)
{
foreach (KeyValuePair <string, string> attachmentPair in attachmentsDictionary)
{
try
{
//create attachment content
attachmentContent[RallyConstant.Content] = attachmentPair.Key;
_attachmentContentCreateResult = _rallyApi.Create(RallyConstant.AttachmentContent, attachmentContent);
_userStoryReference = _attachmentContentCreateResult.Reference;
//create attachment contianer
attachmentContainer[RallyConstant.Artifact] = createUserStory.Reference;
attachmentContainer[RallyConstant.Content] = _userStoryReference;
attachmentContainer[RallyConstant.Name] = attachmentPair.Value;
attachmentContainer[RallyConstant.Description] = RallyConstant.EmailAttachment;
attachmentContainer[RallyConstant.ContentType] = SyncConstant.FileType;
//Create & associate the attachment to the respecitve user story
_attachmentContainerCreateResult = _rallyApi.Create(RallyConstant.Attachment, attachmentContainer);
}
catch (WebException e)
{
Console.WriteLine("Attachment Failed: " + e.Message);
}
}
}
static void Main(string[] args)
{
RallyRestApi restApi;
restApi = new RallyRestApi("*****@*****.**", "secret", "https://rally1.rallydev.com", "v2.0");
String projectRef = "/project/123456"; //use valid OID of your project
Request userRequest = new Request("User");
userRequest.Query = new Query("UserName", Query.Operator.Equals, "*****@*****.**");
QueryResult userResults = restApi.Query(userRequest);
String userRef = userResults.Results.First()._ref;
Console.WriteLine(userRef);
DynamicJsonObject myStory = new DynamicJsonObject();
myStory["Name"] = "a new story";
myStory["Project"] = projectRef;
myStory["Owner"] = userRef;
CreateResult createResult = restApi.Create("HierarchicalRequirement", myStory);
myStory = restApi.GetByReference(createResult.Reference, "FormattedID", "Owner", "Project");
Console.WriteLine(myStory["FormattedID"] + " " + myStory["Owner"]._refObjectName + " " + myStory["Project"]._refObjectName);
}
/// <summary>
/// Creates the userstory with a feature or iteration
/// Both feature and iteration are read only fields
/// </summary>
/// <param name="workspace"></param>
/// <param name="project"></param>
/// <param name="userstory"></param>
/// <param name="userstoryDescription"></param>
/// <param name="userstoryOwner"></param>
public void CreateUserStory(string workspace, string project, string userstory, string userstoryDescription, string userstoryOwner)
{
//authenticate
this.EnsureRallyIsAuthenticated();
//DynamicJsonObject
DynamicJsonObject toCreate = new DynamicJsonObject();
toCreate[RALLY.WorkSpace] = workspace;
toCreate[RALLY.Project] = project;
toCreate[RALLY.Name] = userstory;
toCreate[RALLY.Description] = userstoryDescription;
toCreate[RALLY.Owner] = userstoryOwner;
toCreate[RALLY.PlanEstimate] = "1";
toCreate[RALLY.PortfolioItem] = RALLYQUERY.FeatureShareProject;
//toCreate[RALLY.Iteration] = usIteration;
try
{
CreateResult createUserStory = _rallyRestApi.Create(RALLY.HierarchicalRequirement, toCreate);
Console.WriteLine("Created Userstory: " + createUserStory.Reference);
}
catch (WebException e)
{
Console.WriteLine(e.Message);
}
}
public ResponseMessage <List <Guid> > Get(int pageIndex, int pageSize)
{
int total = 0;
var result = _adminService.LoadEntities(e => true, o => o.Id, "asc", pageIndex, pageSize, out total).Select(e => e.Id).ToList();
return(CreateResult.For(result, total));
}
public void Start_should_check_that_beacon_has_started()
{
var zkClient = Substitute.For <IZooKeeperClient>();
zkClient.CreateAsync(Arg.Any <CreateRequest>()).Returns(Task.FromResult(CreateResult.Unsuccessful(ZooKeeperStatus.AuthFailed, "", null)));
application = new PortRequiresApplication();
host = new VostokHost(
new TestHostSettings(
application,
s =>
{
SetupEnvironment(s);
s.SetupZooKeeperClient(zkSetup => zkSetup.UseInstance(zkClient));
s.SetupServiceBeacon(
beaconSetup => beaconSetup.SetupReplicaInfo(
replicaInfoSetup => { replicaInfoSetup.SetApplication("auth-test"); }));
})
{
BeaconRegistrationWaitEnabled = true,
BeaconRegistrationTimeout = 2.Seconds()
});
Action checkStart = () => host.Start();
checkStart.Should().Throw <Exception>().Where(e => e.Message.Contains("beacon hasn't registered"));
host.ApplicationState.Should().Be(VostokApplicationState.CrashedDuringInitialization);
}
public ICOContractTests()
{
this.mContractLogger = new Mock <IContractLogger>();
this.mContractState = new Mock <ISmartContractState>();
this.mTransactionExecutor = new Mock <IInternalTransactionExecutor>();
this.persistentState = new InMemoryState();
this.network = new Mock <Network>();
this.mBlock = new Mock <IBlock>();
this.mContractState.Setup(s => s.Block).Returns(this.mBlock.Object);
this.mContractState.Setup(s => s.PersistentState).Returns(this.persistentState);
this.mContractState.Setup(s => s.ContractLogger).Returns(this.mContractLogger.Object);
this.mContractState.Setup(s => s.InternalTransactionExecutor).Returns(this.mTransactionExecutor.Object);
this.serializer = new Serializer(new ContractPrimitiveSerializer(this.network.Object));
this.mContractState.Setup(s => s.Serializer).Returns(this.serializer);
this.sender = "0x0000000000000000000000000000000000000001".HexToAddress();
this.owner = "0x0000000000000000000000000000000000000002".HexToAddress();
this.investor = "0x0000000000000000000000000000000000000003".HexToAddress();
this.identity = "0x0000000000000000000000000000000000000004".HexToAddress();
this.contract = "0x0000000000000000000000000000000000000005".HexToAddress();
this.tokenContract = "0x0000000000000000000000000000000000000006".HexToAddress();
this.kycContract = "0x0000000000000000000000000000000000000007".HexToAddress();
this.mapperContract = "0x0000000000000000000000000000000000000008".HexToAddress();
this.createSuccess = CreateResult.Succeeded(this.tokenContract);
this.name = "Test Token";
this.symbol = "TST";
this.totalSupply = 100 * Satoshis;
this.persistentState.IsContractResult = true;
}
private static string TextSerialize(CreateResult model, IEnumerable <Error> errors)
{
string content = null;
if (model != null)
{
content = model.ShortUrl;
}
else if (errors != null)
{
StringBuilder errorBuilder = new StringBuilder();
foreach (Error error in errors)
{
foreach (string message in error.Messages)
{
errorBuilder.AppendLine("{0}: {1}".FormatWith(error.Parameter, message));
}
}
content = errorBuilder.ToString();
}
if (string.IsNullOrWhiteSpace(content))
{
content = TextMessages.SomethingUnholyGoingOn;
}
return(content);
}
public void RemoveFromCollection2x()
{
RallyRestApi restApi = GetRallyRestApi2x();
DynamicJsonObject newStory = new DynamicJsonObject();
newStory["Name"] = "Test Story";
var itemRef = restApi.Create("hierarchicalrequirement", newStory).Reference;
DynamicJsonObject newDefect = new DynamicJsonObject();
newDefect["Name"] = "New Defect Added via collection";
newDefect["Requirement"] = itemRef;
CreateResult newTaskResult = restApi.Create("defect", newDefect);
DynamicJsonObject story = restApi.GetByReference(itemRef, "Defects");
Assert.AreEqual(1, story["Defects"]["Count"]);
DynamicJsonObject taskToRemove = new DynamicJsonObject();
taskToRemove["_ref"] = newTaskResult.Reference;
OperationResult result = restApi.RemoveFromCollection(itemRef, "Defects", new List <DynamicJsonObject>()
{
taskToRemove
}, new NameValueCollection());
Assert.IsTrue(result.Success);
Assert.AreEqual(0, result.Results.Count);
story = restApi.GetByReference(itemRef, "Defects");
Assert.AreEqual(0, story["Defects"]["Count"]);
// Now delete the defect and story
TestHelperDeleteItem(restApi, newTaskResult.Reference);
TestHelperDeleteItem(restApi, itemRef);
}
/// <summary>
/// <para>新規ユーザーを登録します.</para>
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public UserCreateResultModel CreateUser(CreateUserModel model)
{
CreateResult result = CreateResult.Success;
ValidationErrors validErrors = ValidationErrors.Create();
string errorMessage = string.Empty;
try
{
var user = model.CreateUser();
var identityResult = UserMng.Create(user, model.Password);
if (!identityResult.Succeeded)
{
result = CreateResult.Failed;
errorMessage = CreateErrorMessage(identityResult.Errors);
}
}
catch (TemplateValidationException e)
{
result = CreateResult.ValidError;
validErrors = e.ValidErrors;
}
catch
{
result = CreateResult.Failed;
}
return(UserCreateResultModel.Create(model, result, validErrors, errorMessage));
}
public void CreateAsyncTest()
{
TimeoutHelper.ThrowExceptionInTimeout(() =>
{
CreateResult result = null;
var identifier = System.Guid.NewGuid().ToString();
try
{
var creation_group_result = APIReference.Instance.LargePersonGroupInstance.CreateAsync(identifier, identifier, identifier).Result;
System.Diagnostics.Trace.Write($"Creation Result: {creation_group_result}");
if (creation_group_result)
{
result = APIReference.Instance.LargePersonGroupPersonInstance.CreateAsync(identifier, identifier, identifier).Result;
}
}
catch
{
throw;
}
finally
{
var deletion_person_result = APIReference.Instance.LargePersonGroupPersonInstance.DeleteAsync(identifier, result.personId).Result;
System.Diagnostics.Trace.Write($"Deletion Result: {deletion_person_result}");
var deletion_group_result = APIReference.Instance.LargePersonGroupInstance.DeleteAsync(identifier).Result;
System.Diagnostics.Trace.Write($"Deletion Result: {deletion_group_result}");
}
Assert.True(result != null);
});
}
static void Main(string[] args)
{
RallyRestApi restApi = new RallyRestApi(webServiceVersion: "v2.0");
String apiKey = "_abc777";
restApi.Authenticate(apiKey, "https://rally1.rallydev.com", allowSSO: false);
String workspaceRef = "/workspace/123";
String projectRef = "/project/134";
DynamicJsonObject badDefect = new DynamicJsonObject();
badDefect["Name"] = "bad defect 2" + DateTime.Now;
badDefect["Project"] = projectRef;
CreateResult createRequest = restApi.Create(workspaceRef, "Defect", badDefect);
badDefect = restApi.GetByReference(createRequest.Reference, "FormattedID", "Project", "State");
Console.WriteLine(badDefect["FormattedID"] + " " + badDefect["Project"]._refObjectName + " " + badDefect["State"]);
badDefect["State"] = "Open";
OperationResult updateRequest = restApi.Update(badDefect["_ref"], badDefect);
Console.WriteLine("Success? " + updateRequest.Success);
Console.WriteLine("updated State: " + badDefect["State"]);
}
public async Task <CreateResult> CreateAsync(CreateInput input)
{
var requestTemplate = @"
<methodCall>
<methodName>domain.create</methodName>
<params>
<param> <value><string>§model.ApiKey§</string></value></param>
<param> <value><string>§model.Data.Domain§</string></value></param>
<param>
<struct>
<member><name>admin</name><value><string>§model.Data.DomainCreate.Admin§</string></value></member>
<member><name>bill</name><value><string>§model.Data.DomainCreate.Bill§</string></value></member>
<member><name>owner</name><value><string>§model.Data.DomainCreate.Owner§</string></value></member>
<member><name>tech</name><value><string>§model.Data.DomainCreate.Tech§</string></value></member>
<member><name>duration</name><value><int>§model.Data.DomainCreate.Duration§</int></value></member>
</struct></param>
</params>
</methodCall>";
var methodResponse = await MethodResponse(requestTemplate, input);
var result = new CreateResult();
return(result);
}
private async Task <CreateResult> CreateWithParents(CreateRequest request)
{
while (true)
{
var parentPath = ZooKeeperPath.GetParentPath(request.Path);
if (parentPath == null)
{
return(CreateResult.Unsuccessful(
ZooKeeperStatus.BadArguments,
request.Path,
new ArgumentException($"Can't get parent path for `{request.Path}`")));
}
var result = await CreateAsync(new CreateRequest(parentPath, CreateMode.Persistent)).ConfigureAwait(false);
if (!result.IsSuccessful && result.Status != ZooKeeperStatus.NodeAlreadyExists)
{
return(CreateResult.Unsuccessful(result.Status, request.Path, result.Exception));
}
result = await ExecuteOperation(new CreateOperation(request)).ConfigureAwait(false);
if (result.Status != ZooKeeperStatus.NodeNotFound)
{
return(result);
}
// Note(kungurtsev): someone has deleted our parent since we checked, create it again.
}
}
public void CreateStakingMarket_Success()
{
const uint transactionFee = 3;
var marketOwner = Owner;
var createParams = new object[] { transactionFee, StakingToken };
SetupCreate <OpdexStakingMarket>(CreateResult.Succeeded(StakingMarket), 0, createParams);
var createRouterParams = new object[] { StakingMarket, transactionFee, false, false };
SetupCreate <OpdexRouter>(CreateResult.Succeeded(Router), 0, createRouterParams);
var deployer = CreateNewOpdexMarketDeployer();
SetupMessage(Deployer, marketOwner);
State.SetContract(StakingToken, true);
var market = deployer.CreateStakingMarket(StakingToken);
market.Should().Be(StakingMarket);
VerifyLog(new CreateMarketLog
{
Market = StakingMarket,
Owner = marketOwner,
Router = Router,
TransactionFee = transactionFee,
StakingToken = StakingToken,
MarketFeeEnabled = true
}, Times.Once);
}
public void CreateStandardPool_Success(bool authProviders, bool authTraders, uint fee)
{
const bool authPoolCreators = false;
var market = CreateNewOpdexStandardMarket(authPoolCreators, authProviders, authTraders, fee);
State.SetContract(Token, true);
var parameters = new object[] { Token, market.TransactionFee, market.AuthProviders, market.AuthTraders, false };
SetupCreate <OpdexStandardPool>(CreateResult.Succeeded(Pool), parameters: parameters);
var pool = market.CreatePool(Token);
market.GetPool(Token).Should().Be(pool).And.Be(Pool);
market.AuthProviders.Should().Be(authProviders);
market.AuthTraders.Should().Be(authTraders);
market.TransactionFee.Should().Be(fee);
market.Owner.Should().Be(Owner);
var expectedPoolCreatedLog = new CreateLiquidityPoolLog {
Token = Token, Pool = Pool
};
VerifyLog(expectedPoolCreatedLog, Times.Once);
}
public void CreateStandardMarket_Success(bool authPoolCreators, bool authProviders, bool authTraders, uint fee)
{
var marketOwner = Trader0;
var createParams = new object[] { marketOwner, authPoolCreators, authProviders, authTraders, fee };
SetupCreate <OpdexStandardMarket>(CreateResult.Succeeded(StandardMarket), 0, createParams);
var deployer = CreateNewOpdexMarketDeployer();
SetupMessage(Deployer, Owner);
var market = deployer.CreateStandardMarket(marketOwner, authPoolCreators, authProviders, authTraders, fee);
market.Should().Be(StandardMarket);
VerifyLog(new CreateMarketLog
{
Market = StandardMarket,
Owner = marketOwner,
AuthPoolCreators = authPoolCreators,
AuthProviders = authProviders,
AuthTraders = authTraders,
Fee = fee
}, Times.Once);
}
public async Task Create_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
{
var args = new CreateArgs();
await args.ReadAsync(iprot, cancellationToken);
await iprot.ReadMessageEndAsync(cancellationToken);
var result = new CreateResult();
try
{
result.Success = await _iAsync.CreateAsync(args.Person, cancellationToken);
await oprot.WriteMessageBeginAsync(new TMessage("Create", TMessageType.Reply, seqid), cancellationToken);
await result.WriteAsync(oprot, cancellationToken);
}
catch (TTransportException)
{
throw;
}
catch (Exception ex)
{
Console.Error.WriteLine("Error occurred in processor:");
Console.Error.WriteLine(ex.ToString());
var x = new TApplicationException(TApplicationException.ExceptionType.InternalError, " Internal error.");
await oprot.WriteMessageBeginAsync(new TMessage("Create", TMessageType.Exception, seqid), cancellationToken);
await x.WriteAsync(oprot, cancellationToken);
}
await oprot.WriteMessageEndAsync(cancellationToken);
await oprot.Transport.FlushAsync(cancellationToken);
}
static void Main(string[] args)
{
RallyRestApi restApi = new RallyRestApi(webServiceVersion: "v2.0");
String apiKey = "_abc123";
restApi.Authenticate(apiKey, "https://rally1.rallydev.com", allowSSO: false);
String workspaceRef = "/workspace/123";
String projectRef = "/project/456";
Request request = new Request("PortfolioItem/Feature");
request.Fetch = new List <string>()
{
"Name", "FormattedID"
};
request.Query = new Query("FormattedID", Query.Operator.Equals, "F2356");
QueryResult result = restApi.Query(request);
String featureRef = result.Results.First()._ref;
Console.WriteLine("found" + featureRef);
//create stories
try
{
for (int i = 1; i <= 25; i++)
{
DynamicJsonObject story = new DynamicJsonObject();
story["Name"] = "story " + i;
story["PlanEstimate"] = new Random().Next(2, 10);
story["PortfolioItem"] = featureRef;
story["Project"] = projectRef;
CreateResult createResult = restApi.Create(workspaceRef, "HierarchicalRequirement", story);
story = restApi.GetByReference(createResult.Reference, "FormattedID");
Console.WriteLine("creating..." + story["FormattedID"]);
}
//read stories
DynamicJsonObject feature = restApi.GetByReference(featureRef, "UserStories");
Request storiesRequest = new Request(feature["UserStories"]);
storiesRequest.Fetch = new List <string>()
{
"FormattedID",
"PlanEstimate"
};
storiesRequest.Limit = 1000;
QueryResult storiesResult = restApi.Query(storiesRequest);
int storyCount = 0;
foreach (var userStory in storiesResult.Results)
{
Console.WriteLine(userStory["FormattedID"] + " " + userStory["PlanEstimate"]);
storyCount++;
}
Console.WriteLine(storyCount);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public void StartGame_Success()
{
// Set up create for player vs opponent.
this.mockInternalExecutor.Setup(s =>
s.Create <Player>(
It.IsAny <ISmartContractState>(),
It.IsAny <ulong>(),
It.Is <object[]>(o =>
(Address)o[0] == PlayerAddress &&
(Address)o[1] == OpponentAddress),
It.IsAny <ulong>()))
.Returns(CreateResult.Succeeded(PlayerContractAddress));
// Set up create for opponent vs player.
this.mockInternalExecutor.Setup(s =>
s.Create <Player>(
It.IsAny <ISmartContractState>(),
It.IsAny <ulong>(),
It.Is <object[]>(o =>
(Address)o[0] == OpponentAddress &&
(Address)o[1] == PlayerAddress),
It.IsAny <ulong>()))
.Returns(CreateResult.Succeeded(OpponentContractAddress));
var starter = new Starter(this.mockContractState.Object);
starter.StartGame(PlayerAddress, OpponentAddress, "Test");
this.mockInternalExecutor.Verify(
s => s.Create <Player>(
this.mockContractState.Object,
0,
It.Is <object[]>(o =>
(Address)o[0] == PlayerAddress &&
(Address)o[1] == OpponentAddress &&
(string)o[2] == "Test"),
0), Times.Once);
this.mockInternalExecutor.Verify(
s => s.Create <Player>(
this.mockContractState.Object,
0,
It.Is <object[]>(o =>
(Address)o[0] == OpponentAddress &&
(Address)o[1] == PlayerAddress &&
(string)o[2] == "Test"),
0), Times.Once);
this.mockContractLogger.Verify(
l => l.Log(
It.IsAny <ISmartContractState>(),
new Starter.GameCreated
{
Player1Contract = PlayerContractAddress,
Player2Contract = OpponentContractAddress,
GameName = "Test"
}),
Times.Once);
}
public ResponseMessage <List <AEmployee> > Get()
{
var list = _employeeService.LoadEntities(e => true).Select(e => new AEmployee {
Id = e.Id, Name = e.Name
}).ToList();
return(CreateResult.For(list));
}
public ResponseMessage <IEnumerable <Dictionary <string, string> > > Get()
{
var list = from c in User.Claims select new Dictionary <string, string> {
{ c.Type, c.Value }
};
return(CreateResult.For(list));
}
public ResponseMessage <List <T_Teacher> > GetTeachersList_D()
{
dynamic result;
var list = _SqlDB.Query <T_Teacher>("SELECT * FROM T_Teacher");
result = CreateResult.For(list, list.Count);
return(result);
}
public static TodoItemCreateResultModel Create(CreateTodoItemModel model, CreateResult result, ValidationErrors validErrors = null)
{
return(new TodoItemCreateResultModel
{
Name = model.Name,
Result = result,
ValidErrors = validErrors ?? ValidationErrors.Create(),
});
}
public ResponseMessage <List <TTeacher> > GetTeachersList()
{
dynamic result;
var list = _dbContext.TTeacher.ToList();
result = CreateResult.For(list, list.Count);
return(result);
}
protected IOpdexMarketDeployer CreateNewOpdexMarketDeployer()
{
SetupBalance(0);
SetupBlock(10);
SetupMessage(Deployer, Owner);
SetupCreate <OpdexStakingMarket>(CreateResult.Succeeded(StakingMarket), 0ul, new object[] { StakingToken, (uint)3 });
return(new OpdexMarketDeployer(_mockContractState.Object, StakingToken));
}
