public void Report_NewRobotAt1X1YNorth_Returns1X1YNorth()
{
var board = new Toy.Robot.Board.Board();
_coordinator = new Toy.Robot.Coordinator(board);
_coordinator.InitializeBoard(5, 5);
var robotId = Guid.NewGuid();
_coordinator.Place(robotId, 1, 1, Direction.North);
try
{
var report = _coordinator.Report();
Assert.AreEqual(1, report.Count);
var firstRobot = report.First();
Assert.AreEqual(robotId, firstRobot.robotId);
Assert.AreEqual(1, firstRobot.x);
Assert.AreEqual(1, firstRobot.y);
Assert.AreEqual(Direction.North, firstRobot.direction);
}
catch (Exception)
{
Assert.Fail("Exception Thrown");
}
}
public ShellViewModel(ILoggerFacade logger, ICoordinator coordinator, IRegionManager regionManager, IShell shell)
{
Logger = logger;
RegionManager = regionManager;
Coordinator = coordinator;
Shell = shell;
MoveCommand = new DelegateCommand(OnMoveWindow);
MinimizeCommand = new DelegateCommand(OnMinimize);
CloseCommand = new DelegateCommand(OnClose);
ImageDoubleCommand = new DelegateCommand(OnNavigateToAbout);
OpenMenuCommand = new DelegateCommand <object>(OnOpenMenu);
LoadContestCommand = new DelegateCommand(OnLoadContest);
SaveContestCommand = new DelegateCommand(OnSaveContest);
SaveContestAsCommand = new DelegateCommand(OnSaveContestAs);
StartOverCommand = new DelegateCommand(OnStartOver);
UIHelper.ViewChanged += (s, e) => RaisePropertyChanged("MenuActive");
Core.DisplayRequested += (s, e) =>
{
Shell.Activate();
Shell.WindowState = WindowState.Normal;
};
if (Core.Load)
{
Load(Core.LoadPath);
}
Core.LoadRequested += (s, e) => Load(e);
}
public SubscriberRemote(PuppetMaster pm, string name, string site, string coordinatorURI)
{
_serviceName = name;
_pm = pm;
_site = site;
c = (ICoordinator)Activator.GetObject(typeof(ICoordinator), coordinatorURI);
}
public void Transition(ICoordinator parent, ICoordinator current, ICoordinator next)
{
current?.Dismiss();
parent.RemoveChild(current);
next.Present(parent.Delegate);
parent.AddChild(next);
}
public VerificationWorker(string name, ICoordinator coordinator, int maxConcurrentVerifications)
{
Ensure.NotNullOrEmpty(name, "name");
Ensure.NotNull(coordinator, "coordinator");
_worker = new Worker(name, coordinator, WorkerRole.Verifier, maxConcurrentVerifications, OnPackageArrived, Pack);
}
public Worker(string name,
ICoordinator coordinator,
WorkerRole role,
int maxConcurrentItems,
Action <TcpTypedConnection <byte[]>, TcpPackage> onPackageArrived,
Func <Guid, VerificationEvent, TcpPackage> packager)
{
Ensure.NotNullOrEmpty(name, "name");
Ensure.NotNull(coordinator, "coordinator");
Ensure.NotNull(onPackageArrived, "onPackageArrived");
Ensure.NotNull(packager, "packager");
_name = name;
_coordinator = coordinator;
_role = role;
_maxConcurrentItems = maxConcurrentItems;
_onPackageArrived = onPackageArrived;
_packager = packager;
_thread = new Thread(MainLoop)
{
IsBackground = true,
Name = string.Format("Worker - {0}", name)
};
}
public VerificationWorker(string name, ICoordinator coordinator, int maxConcurrentVerifications)
{
Ensure.NotNullOrEmpty(name, "name");
Ensure.NotNull(coordinator, "coordinator");
_worker = new Worker(name, coordinator, WorkerRole.Verifier, maxConcurrentVerifications, OnPackageArrived, Pack);
}
public ManageStudentController(ICoordinator coordinator, IUsers users, IStudent student, IUsersInRoles usersInRoles)
{
_users = users;
_student = student;
_usersInRoles = usersInRoles;
_coordinator = coordinator;
}
public LauncherService()
{
rootWorkItemService = SpringUtil.GetObject<IRootWorkItemService>("RootWorkItemService");
workItem = rootWorkItemService.RootWorkItem;
coordinator = workItem.Services.Get<ICoordinator>();
}
public ArimaModelRepository(ICoordinator coordinator)
{
_coordinator = coordinator;
_client = new HttpClient();
this._jsonSerializerOptions = new JsonSerializerOptions();
_jsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
}
public Worker(string name,
ICoordinator coordinator,
WorkerRole role,
int maxConcurrentItems,
Action<TcpTypedConnection<byte[]>, TcpPackage> onPackageArrived,
Func<Guid, VerificationEvent, TcpPackage> packager)
{
Ensure.NotNullOrEmpty(name, "name");
Ensure.NotNull(coordinator, "coordinator");
Ensure.NotNull(onPackageArrived, "onPackageArrived");
Ensure.NotNull(packager, "packager");
_name = name;
_coordinator = coordinator;
_role = role;
_maxConcurrentItems = maxConcurrentItems;
_onPackageArrived = onPackageArrived;
_packager = packager;
_thread = new Thread(MainLoop)
{
IsBackground = true,
Name = string.Format("Worker - {0}", name)
};
}
public PublisherRemote(PuppetMaster pm, string name, string site, string addr)
{
_serviceName = name;
_pm = pm;
_site = site;
c = (ICoordinator)Activator.GetObject(typeof(ICoordinator), addr);
}
public ManageTeacherController(ICoordinator coordinator, IUsers users, ITeacher teacher, IUsersInRoles usersInRoles)
{
_users = users;
_teacher = teacher;
_usersInRoles = usersInRoles;
_coordinator = coordinator;
}
public LoginPage(ICoordinator coordinator)
{
InitializeComponent();
BindingContext = ViewModel = new LoginViewModel();
this.AttachHooks();
this.AttachCoordinator(coordinator);
}
public ContestDimensionsViewModel(ILoggerFacade logger, IRegionManager regionManager, ICoordinator coordinator)
{
Logger = logger;
RegionManager = regionManager;
Coordinator = coordinator;
NextCommand = new DelegateCommand(OnNext);
}
public void RemoveChild(ICoordinator coordinator)
{
if (!_children.Contains(coordinator))
{
return;
}
_children.Remove(coordinator);
}
public void AddChild(ICoordinator coordinator)
{
if (_children.Contains(coordinator))
{
return;
}
_children.Add(coordinator);
}
public HomeCoordinator(
IContainer container,
UINavigationController navigationController,
ICoordinator parentCoordinator)
: base(navigationController)
{
this.container = container;
this.parentCoordinator = parentCoordinator;
}
public void RegisterTypes(ICoordinator coordinator)
{
_container.Register <ICoordinator>(coordinator)
.WhenInjectedInto(typeof(IController)) // can only be injected into IController
.In(Lifetime.Container());
var module = new RegistrationModlule(coordinator.PairManager.ViewControllerPairs);
_container.RegisterModule(module);
}
internal void getDecision(object source, ElapsedEventArgs e)
{
// Hipotese: Se timer expirar, perguntar ao coordenador decisao final
ICoordinator coord = (ICoordinator)Activator.GetObject(typeof(ICoordinator), _coordinatorURL);
//It is assumed that if the coordinator fails to respond, the transaction is
//Alternative strategies are available for the participants to obtain a decision
// cooperatively instead of contacting the coordinato
coord.haveCommitted(TX.TXID, MY_URL);
// save decision
}
public AbstractCoordinatorDecorator(ICoordinator next) : base()
{
#region Precondizioni
if (next == null)
{
throw new ArgumentNullException("coordinatore interno nullo");
}
#endregion
_next = next;
_next.Changed += NextCoordinatorChangedHandler;
}
private void Init()
{
_init = true;
_coordinator = new CategoryCoordinator(_coordinator);
_coordinator = new StructureCoordinator(_coordinator);
_coordinator = new ServiceCoordinator(_coordinator);
_coordinator = new BookingCoordinator(_coordinator);
_coordinator = new UserCoordinator(_coordinator);
_coordinator = new TrackingDeviceCoordinator(_coordinator);
_coordinator = new ItemCoordinator(_coordinator);
_coordinator = new PrenotationCoordinator(_coordinator);
}
public BootstrapPage(ICoordinator coordinator)
{
InitializeComponent();
BindingContext = ViewModel = new BootstrapViewModel();
// Start the boostrap process
this.AttachHooks();
this.AttachCoordinator(coordinator);
// Auto-start the bootstrap process
ViewModel.StartCommand.Execute(null);
}
public void AttachCoordinator(ICoordinator coordinator)
{
this.DetachCoordinator();
// Save a reference to the workflow (so that it does not get garbage collected
this.Coordinator = coordinator;
// Give the workflow a weak reference to self
if (coordinator != null)
{
coordinator.AttachToPage(this);
}
}
/// <summary>
/// Main
/// </summary>
/// <param name="args">args</param>
static void Main(string[] args)
{
//Configure object to object mapping
AutoMapperConfig.Configure();
//Resolve starting point of application
IUnityContainer container = UnityConfig.Configure();
ICoordinator coordinator = container.Resolve <ICoordinator>();
//Process power consumption and apply rules
coordinator.ProcessConsumption();
System.Console.Read();
}
/// <summary>
/// calculate editor bounds
/// </summary>
/// <returns></returns>
public override Rectangle Bounds()
{
Rectangle rect = new Rectangle();
if (_column != null)
{
rect = ((TableControl)parentControl).getCellRect(_column.Index, RowIdx);
if (IsHeaderEditor)
{
ICoordinator coordinator = BoundsComputer as ICoordinator;
if (coordinator != null)
{
if (coordinator.X < 0)
{
TableControl tableControl = (TableControl)parentControl;
// Defect# 130148: When a column is re-ordered with 1st column, then only use actual co-ordinates for X,
// otherwise this problem occurs i.e. control from 1st column remains at same location
if ((!(tableControl.RightToLeftLayout) && _column.Index == 0) ||
(tableControl.RightToLeftLayout && tableControl.ColumnCount - 1 == _column.Index))
{
rect.X = coordinator.X;
}
}
rect.Y = coordinator.Y < 0 ? coordinator.Y : 0;
}
rect.Height = Math.Abs(rect.Y) + ((TableControl)parentControl).Height;
if (((TableControl)parentControl).RightToLeftLayout)
{
rect.Width = rect.Width + rect.X;
rect.X = 0;
}
else
{
rect.Width = parentControl.Bounds.Width - rect.X;
}
}
}
// Defect 140258: If header control is hidden when column to which it is attached is hidden,
// BoundsComputer is null. So return empty rectangle in this case.
if (BoundsComputer != null)
{
return(BoundsComputer.computeEditorBounds(rect, IsHeaderEditor));
}
else
{
return(Rectangle.Empty);
}
}
public Worker(string name, ICoordinator coordinator, int maxConcurrentItems)
{
Ensure.NotNullOrEmpty(name, "name");
Ensure.NotNull(coordinator, "coordinator");
_name = name;
_coordinator = coordinator;
_maxConcurrentItems = maxConcurrentItems;
_thread = new Thread(MainLoop)
{
IsBackground = true,
Name = string.Format("Worker {0} main loop", name)
};
}
internal void canCommit()
{
Console.WriteLine("I'm the participant: " + MY_URL);
Console.WriteLine("Coordinator URL: " + _coordinatorURL);
ICoordinator coord = (ICoordinator)Activator.GetObject(typeof(ICoordinator), _coordinatorURL);
MY_DECISION = TransactionDecision.COMMIT;
// writeAheadLog();
timer();
coord.sendYes(TX.TXID, MY_URL);
MY_DECISION = waitForCoordinator();
}
public Worker(string name, ICoordinator coordinator, int maxConcurrentItems)
{
Ensure.NotNullOrEmpty(name, "name");
Ensure.NotNull(coordinator, "coordinator");
_name = name;
_coordinator = coordinator;
_maxConcurrentItems = maxConcurrentItems;
_thread = new Thread(MainLoop)
{
IsBackground = true,
Name = string.Format("Worker {0} main loop", name)
};
}
public DataServer(ICoordinator <IFlow> coordinator,
Func <int, TypeModel, IFlow> flowBuilder,
TypeModel customSerializer)
{
if (coordinator == null)
{
throw new ArgumentNullException();
}
if (flowBuilder == null)
{
throw new ArgumentNullException();
}
this.coordinator = coordinator;
this.customSerializer = customSerializer;
this.flowBuilder = flowBuilder;
}
public void Place_NewRobot1X1YNorth_RobotPlaced()
{
_mockBoard.Setup(m => m.Place(It.IsAny <Guid>(), It.IsAny <int>(), It.IsAny <int>()));
_coordinator = new Toy.Robot.Coordinator(_mockBoard.Object);
_coordinator.InitializeBoard(5, 5);
var robotId = Guid.NewGuid();
Assert.DoesNotThrow(() =>
{
_coordinator.Place(robotId, 1, 1, Direction.North);
});
_mockBoard.Verify(m => m.Place(robotId, 1, 1), Times.Once);
Assert.AreEqual(1, _coordinator.Robots.Count);
}
public void Report_RobotExistsInListNotOnBoard_ExceptionThrown()
{
var board = new Toy.Robot.Board.Board();
_coordinator = new Toy.Robot.Coordinator(board);
_coordinator.InitializeBoard(5, 5);
_coordinator.Robots.Add(new Toy.Robot.Robot.Robot(Direction.North));
var ex = Assert.Throws <Exception>(() =>
{
_coordinator.Report();
});
Assert.AreEqual("Cannot find robot on the board, place same robot on the board again", ex.Message);
}
public void Move_RobotDoesNotExistOnBoard_ExceptionThrown()
{
var board = new Toy.Robot.Board.Board();
board.InitializePlayArea(5, 5);
var robotId = Guid.NewGuid();
_coordinator = new Toy.Robot.Coordinator(board);
_coordinator.Robots.Add(new Toy.Robot.Robot.Robot(Direction.North, robotId));
var ex = Assert.Throws <Exception>(() =>
{
_coordinator.Move(robotId);
});
Assert.AreEqual("Cannot find robot on the board, place same robot on the board again", ex.Message);
}
public void Report_MultipleRobots_NoExceptionsResultsValid()
{
var board = new Toy.Robot.Board.Board();
_coordinator = new Toy.Robot.Coordinator(board);
_coordinator.InitializeBoard(5, 5);
_coordinator.NumberOfRobotsAllowed = 4;
var expectedResults = new List <(Guid robotId, int x, int y, Direction direction)>
{
(Guid.NewGuid(), 0, 0, Direction.North),
(Guid.NewGuid(), 0, 4, Direction.East),
(Guid.NewGuid(), 4, 0, Direction.West),
(Guid.NewGuid(), 4, 4, Direction.South)
};
_coordinator.Place(expectedResults[0].robotId, expectedResults[0].x, expectedResults[0].y, expectedResults[0].direction);
_coordinator.Place(expectedResults[1].robotId, expectedResults[1].x, expectedResults[1].y, expectedResults[1].direction);
_coordinator.Place(expectedResults[2].robotId, expectedResults[2].x, expectedResults[2].y, expectedResults[2].direction);
_coordinator.Place(expectedResults[3].robotId, expectedResults[3].x, expectedResults[3].y, expectedResults[3].direction);
try
{
var reportList = _coordinator.Report();
Assert.AreEqual(4, reportList.Count);
foreach (var expectedResult in expectedResults)
{
var report = reportList.FirstOrDefault(r => r.robotId == expectedResult.robotId);
if (report == default)
{
Assert.Fail($"Robot {expectedResult.robotId} not included in report");
}
Assert.AreEqual(expectedResult, report);
}
}
catch (Exception)
{
Assert.Fail("Exception Thrown");
}
}
static void Main(string[] args)
{
Log.Logger = SetupLogger();
var scraperBuilder = new ScraperBuilder(config =>
{
config.ScraperNo = int.Parse(ConfigurationManager.AppSettings["ScraperNo"]);
config.DBreezeDataFolderName = ConfigurationManager.AppSettings["DBreezeDataFolderName"];
config.Scrapers = int.Parse(ConfigurationManager.AppSettings["Scrapers"]);
config.SyncInterval = int.Parse(ConfigurationManager.AppSettings["SyncInterval"]);
config.ScraperConnectionString = ConfigurationManager.AppSettings["ScraperConnectionString"];
});
ICoordinator controller = scraperBuilder.Build();
controller.Start();
Console.ReadLine();
controller.Stop();
Console.ReadLine();
}
public void Move_RobotExistsAt1X1YNorthFacing_BoardPlaceIsFiredWith1X2Y()
{
var playArea = new Guid[5, 5];
playArea.Initialize();
var robotId = Guid.NewGuid();
playArea[1, 1] = robotId;
_mockBoard = new Mock <IBoard>();
_mockBoard.Setup(m => m.Place(It.IsAny <Guid>(), It.IsAny <int>(), It.IsAny <int>()));
_mockBoard.Setup(m => m.PlayArea).Returns(playArea);
_coordinator = new Toy.Robot.Coordinator(_mockBoard.Object);
_coordinator.Robots.Add(new Toy.Robot.Robot.Robot(Direction.North, robotId));
Assert.DoesNotThrow(() =>
{
_coordinator.Move(robotId);
});
_mockBoard.Verify(m => m.Place(robotId, 1, 2), Times.Once(), "Place was not called with correct parameters");
}
public TestManager(ICoordinator c)
: base(c)
{
}
private ICoordinator GetCoordinator()
{
return _coordinator ??
(_coordinator = (ICoordinator) Activator.GetObject(typeof (IMainServer), Config.RemoteMainserverUrl));
}
public void setLoggingLevel(LoggingLevel l)
{
_loggingLevel = l;
if (l == LoggingLevel.full)
{
c = (ICoordinator)Activator.GetObject(typeof(ICoordinator), _coordinatorURI);
}
}
private void StartCoordinator()
{
_coordinator = new Coordinator();
_coordinator.Start();
Console.WriteLine("I am the new Coordinator!");
_election.SetCoordinator();
}
public WriteWorker(string name, ICoordinator coordinator, int maxconcurrentWrites)
{
_worker = new Worker(name, coordinator, WorkerRole.Writer, maxconcurrentWrites, OnPackageArrived, Pack);
}
/// <summary>
/// Constructor for Mocking
/// </summary>
/// <param name="coordinator">Coordinator</param>
public CoordinatedTask(ICoordinator coordinator)
: base(coordinator.PeriodInSeconds + 1)
{
this.coordinator = coordinator;
}
public ClientService(ISerializer serializer, ICoordinator coordinator, IWorldFactory worldFactory)
{
_serializer = serializer;
_coordinator = coordinator;
_worldFactory = worldFactory;
}
public Participant(int serverId, IStorage storage)
{
_coordinator = (ICoordinator) Activator.GetObject(typeof (ICoordinator), Config.RemoteMainserverUrl);
_serverId = serverId;
_status.storage = storage;
}
