public void CanGetAll()
{
var apiEntities = new[]
{
new ApiSample
{
Id = Guid.NewGuid()
},
new ApiSample
{
Id = Guid.NewGuid()
}
};
var idsBefore = apiEntities.Select(x => x.Id);
var sampleController = new SampleController(this.service);
var resultEntities = sampleController.GetAllAsync().Result.ToArray();
Assert.AreEqual(0, resultEntities.Length);
this.service.WriteAsync(apiEntities).Wait();
var resultIds = sampleController.GetAllAsync().Result.Select(x => x.Id).ToArray();
CollectionAssert.AreEquivalent(idsBefore, resultIds);
}
void Awake()
{
Debug.Log("--------------- Awake ------------------------");
XTC.oelMVCS.Logger logger = new UnityLogger();
UIFacade.logger = logger;
foreach (UIFacade facade in uIFacades)
{
facade.Register();
}
framework.setLogger(logger);
framework.setConfig(new Config());
framework.Initialize();
SampleModel model = new SampleModel();
SampleView view = new SampleView();
SampleController controller = new SampleController();
SampleService service = new SampleService();
service.mono = this;
service.MockProcessor = service.mockProcessor;
service.useMock = true;
framework.getStaticPipe().RegisterModel(SampleModel.NAME, model);
framework.getStaticPipe().RegisterView(SampleView.NAME, view);
framework.getStaticPipe().RegisterController(SampleController.NAME, controller);
framework.getStaticPipe().RegisterService(SampleService.NAME, service);
}
public void GetParameter_should_return_value_type_parameters()
{
var controller = new SampleController();
var result = controller.TestMethod();
var parameter = result.GetStronglyTypedParameter(controller, "number");
Assert.That(parameter, Is.EqualTo(1));
}
/// Step A - PREPROCESS
public void preprocessAlgoData(string currentPatientID)
{
/// 1. Get latest sample
SampleController sampleController = new SampleController();
latestSample = sampleController.GetLatestSampleForPatient(currentPatientID);
//insert caregivers to caregiversArr
PatientController patientController = new PatientController();
caregiversArr = patientController.GetCaregiversforPatientID(currentPatientID);
//extract patient's known locations
LocationController locationController = new LocationController();
knownLocations = locationController.GetKnownLocationsforPatientID(currentPatientID);
//get latest sample time
sampleTime = latestSample.CreatedAt.Value;
//get avg patient's HR, and set our limits
AVG_PATIENT_HR = AlgoUtils.avgHeartRate(currentPatientID);
HEART_RATE_BOTTOM_LIMIT = 1.7 * AVG_PATIENT_HR;
HEART_RATE_TOP_LIMIT = 0.5 * AVG_PATIENT_HR;
}
public void Can_Retrieve_Sample_Thumbnail_Data()
{
// Arrange - create a Sample with image (thumbnail) data
Sample sample = new Sample
{
Id = 1,
Thumbnail = new byte[] { }
};
// Arrange - create the mock repository
Mock <IRepository <Sample> > mock = new Mock <IRepository <Sample> >();
mock.Setup(m => m.Get(1)).Returns(sample);
// Arrange - create the controller
SampleController target = new SampleController(mock.Object);
// Act - call the Thumbnail method
HttpResponseMessage result = target.Thumbnail(1);
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(HttpResponseMessage));
Assert.AreEqual(result.Content.Headers.ContentType.MediaType, "image/png");
}
void Reset()
{
controller = new SampleController();
controller.animator = GetComponent <Animator> ();
controller.FloatParameter = 32;
var result = controller.FloatParameter;
}
public void getEvenOddNumberTest()
{
SampleController controller = new SampleController();
Assert.AreEqual(controller.getEvenOddNumber(5, true), "2,4");
//Assert.AreEqual(controller.getEvenOddNumber(5, false), "1,3,5");
}
void Reset()
{
controller = new SampleController ();
controller.animator = GetComponent<Animator> ();
controller.FloatParameter = 32;
var result = controller.FloatParameter;
}
public void Initiolize(SampleController sampleController)
{
characterStatus = sampleController.characterStatus;
targetLook = sampleController.cameraHandler.targetLook;
cameraSystem = sampleController.cameraHandler.mainTransform.gameObject;
noPlayerMask = sampleController.cameraHandler.noPlayerMask;
cam = sampleController.cameraHandler.cameraTransform.gameObject;
anim = sampleController.anim;
characterInput = sampleController.characterInput;
characterFight = sampleController.characterFight;
characterIK = sampleController.characterIK;
ammoSlider = sampleController.ammoSlider;
if (characterFight != null)
{
sword = Instantiate(fightWeapon.weaponPrefab, fightPoint);
ReturnSwordToPos();
activeFightWeapon = sword.GetComponent <FightWeapon>();
characterInput.fightWeapon = activeFightWeapon;
characterFight.weapon = activeFightWeapon;
anim.SetBool("Weapon", true);
anim.SetInteger("WeaponType", 0);
fighter = true;
}
itemText.text = string.Empty;
}
public void SampleController_IndexTest()
{
SampleController sampleController = new SampleController();
var result = sampleController.Index() as ViewResult;
Assert.AreEqual("Index", result.ViewName);
}
public async Task Get_ReturnOK_WithPingTrue()
{
// Arrange
var dbContext = await GetSqliteDbContextAsync();
var loggerMock = new Mock <ILogger <SampleController> >();
var logger = loggerMock.Object;
var fooMock = new Mock <IFoo>();
fooMock.Setup(foo => foo.Ping("localhost")).Returns(true);
var foo = fooMock.Object;
var controller = new SampleController(dbContext, logger, foo);
// Act
var response = await controller.Get(2);
var responseModel = ((OkObjectResult)response).Value as SampleEntity;
// Assert
Assert.IsInstanceOfType(response, typeof(OkObjectResult));
Assert.IsTrue(responseModel.Id == 2);
Assert.IsFalse(responseModel.BoolValue);
Assert.IsTrue(responseModel.StringValue == "ping");
}
public async Task Get_ReturnOK_WithPingTrue_UsingFluentAssertions()
{
// Arrange
var dbContext = await GetSqliteDbContextAsync();
var loggerMock = new Mock <ILogger <SampleController> >();
var logger = loggerMock.Object;
var fooMock = new Mock <IFoo>();
fooMock.Setup(foo => foo.Ping("localhost")).Returns(true);
var foo = fooMock.Object;
var controller = new SampleController(dbContext, logger, foo);
// Act
var response = await controller.Get(2);
// Assert
var result = response.Should().BeOfType <OkObjectResult>().Subject;
var sampleData = result.Value.Should().BeAssignableTo <SampleEntity>().Subject;
sampleData.Id.Should().Be(2);
sampleData.BoolValue.Should().BeFalse();
sampleData.StringValue.Should().Be("ping");
}
public void Init()
{
requestValidator = new Mock <IRequestValidator>();
sampleService = new Mock <ISampleService>();
controller = new SampleController(requestValidator.Object, sampleService.Object);
}
public void GetParameter_should_return_reference_type_parameters()
{
var controller = new SampleController();
var result = controller.TestMethod();
var parameter = (SampleObject)result.GetStronglyTypedParameter(controller, "obj");
Assert.That(parameter.Name, Is.EqualTo("name"));
}
public void CanGetWithSync()
{
var apiEntity1 = new ApiSample
{
Id = Guid.NewGuid()
};
var apiEntity2 = new ApiSample
{
Id = Guid.NewGuid()
};
var sampleController = new SampleController(this.service);
var apiSync = sampleController.GetAsync(-1).Result;
Assert.AreEqual(0, apiSync.LastSync);
Assert.AreEqual(0, apiSync.Data.Length);
Assert.AreEqual(0, apiSync.DeletedData.Length);
this.service.WriteAsync(apiEntity1).Wait();
apiSync = sampleController.GetAsync(apiSync.LastSync).Result;
Assert.AreEqual(1, apiSync.LastSync);
Assert.AreEqual(1, apiSync.Data.Length);
Assert.AreEqual(apiEntity1.Id, apiSync.Data[0].Id);
Assert.AreEqual(0, apiSync.DeletedData.Length);
this.service.WriteAsync(apiEntity2).Wait();
this.service.RemoveAsync(apiEntity1).Wait();
apiSync = sampleController.GetAsync(apiSync.LastSync).Result;
Assert.AreEqual(3, apiSync.LastSync);
Assert.AreEqual(1, apiSync.Data.Length);
Assert.AreEqual(apiEntity2.Id, apiSync.Data[0].Id);
Assert.AreEqual(1, apiSync.DeletedData.Length);
Assert.AreEqual(apiEntity1.Id, apiSync.DeletedData[0]);
}
public async Task GetAsync_ReturnsAListOfAllTests()
{
// Arrange
mock.Setup(m => m.GetTestsAsync())
.Returns(Task.Run(() => GetSampleTests()));
var sampleController = new SampleController(mock.Object);
var expected = GetSampleTests();
// Act
var result = await sampleController.GetAsync();
// Assert
var okObjectResult = result as OkObjectResult;
Assert.IsNotNull(okObjectResult);
var actual = okObjectResult.Value as IEnumerable <string>;
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Count(), actual.Count());
for (int i = 0; i < expected.Count(); i++)
{
Assert.AreEqual(expected.ElementAt(i), actual.ElementAt(i));
}
}
[TestInitialize] // Initialize TEst
public void Initialize()
{
mockRepo = new Mock <ISampleRepository>(); // Mock Interface to be tested
mockService = new Mock <ISampleService>();
sut = new SampleController(mockRepo.Object, mockService.Object); // Service / System under test
sample = new Sample // model
{
SampleId = new Guid(),
SampleName = "Emmanuel",
Description = "Description"
};
// set up
mockRepo
.Setup(
r => r.Retrieve(existingId)
)
.Returns(sample);
mockRepo
.Setup(
r => r.Retrieve(nonExistingId)
)
.Returns <Sample>(null);
}
public async Task GetAsync_WhenIdExists_ReturnsTheTestWithTheGivenId()
{
// Arrange
int testId = 1;
mock.Setup(m => m.GetTestByIdAsync(testId))
.Returns(Task.Run(() => GetSampleTests().ElementAt(testId)));
var sampleController = new SampleController(mock.Object);
var expected = GetSampleTests().ElementAt(testId);
// Act
var result = await sampleController.GetAsync(testId);
// Assert
var okObjectResult = result as OkObjectResult;
Assert.IsNotNull(okObjectResult);
var actual = okObjectResult.Value as string;
Assert.IsNotNull(actual);
Assert.AreEqual(expected, actual);
}
void Start()
{
//Gg_sliderを取得
_Slider = GameObject.Find("Gg_Slider").GetComponent <Slider>();
_Gg = 0;
Playerobj = GameObject.Find("huton_muki_tset");
Masescript = Playerobj.GetComponent <SampleController>();
}
public async Task Test_TestGetMethod()
{
var messageSession = new NServiceBus.Testing.TestableMessageSession();
var sampleController = new SampleController(messageSession);
var values = await sampleController.GetSomeValues();
Assert.AreEqual("testGet", values);
}
public void GetParameter_should_return_reference_type_parameters()
{
var controller = new SampleController();
var result = controller.TestMethod();
var parameter = (SampleObject)result.GetStronglyTypedParameter(controller, "obj");
Assert.That(parameter.Name, Is.EqualTo("name"));
}
public void GetParameter_should_return_value_type_parameters()
{
var controller = new SampleController();
var result = controller.TestMethod();
var parameter = result.GetStronglyTypedParameter(controller, "number");
Assert.That(parameter, Is.EqualTo(1));
}
public void TestMethod1()
{
var controller = new SampleController();
var result = controller.Index() as ViewResult;
Assert.AreEqual("Index", result.ViewName);
}
public object CreateMainView()
{
var viewModel = new SampleViewModel(new SampleView());
sampleController = new SampleController(logService, eventAggregator, viewModel, () => new DialogViewModel(new DialogWindow()));
sampleController.Initialize();
return(viewModel.View);
}
public void Initiolize(SampleController sampleController)
{
rotateMode = true;
step = Time.fixedDeltaTime * cameraConfig.pivotSpeed;
defaultMask = cam.cullingMask;
characterStatus = sampleController.characterStatus;
characterInput = sampleController.characterInput;
}
void Awake()
{
Debug.Log("--------------- Awake ------------------------");
XTC.oelMVCS.Logger logger = new UnityLogger();
UIFacade.logger = logger;
framework.setLogger(logger);
framework.setConfig(new Config());
btnLoad.onClick.AddListener(() =>
{
btnLoad.gameObject.SetActive(false);
btnDestroy.gameObject.SetActive(true);
GameObject go = Resources.Load <GameObject>("SampleFacade");
uiFacade = GameObject.Instantiate(go);
uiFacade.transform.SetParent(btnLoad.transform.parent);
uiFacade.transform.localScale = Vector3.one;
RectTransform rt = uiFacade.GetComponent <RectTransform>();
rt.anchoredPosition = Vector2.zero;
rt.sizeDelta = Vector2.zero;
uiFacade.GetComponent <UIFacade>().Register();
model = new SampleModel();
view = new SampleView();
controller = new SampleController();
service = new SampleService();
service.MockProcessor = this.mockProcessor;
service.useMock = true;
framework.getDynamicPipe().PushModel(SampleModel.NAME, model);
framework.getDynamicPipe().PushView(SampleView.NAME, view);
framework.getDynamicPipe().PushController(SampleController.NAME, controller);
framework.getDynamicPipe().PushService(SampleService.NAME, service);
});
btnDestroy.onClick.AddListener(() =>
{
btnLoad.gameObject.SetActive(true);
btnDestroy.gameObject.SetActive(false);
framework.getDynamicPipe().PopModel(SampleModel.NAME);
framework.getDynamicPipe().PopView(SampleView.NAME);
framework.getDynamicPipe().PopController(SampleController.NAME);
framework.getDynamicPipe().PopService(SampleService.NAME);
if (uiFacade != null)
{
uiFacade.GetComponent <UIFacade>().Cancel();
GameObject.Destroy(uiFacade);
uiFacade = null;
}
});
framework.Initialize();
}
public void RegisterCaregiver(string ID)
{
Trace.TraceInformation(String.Format("Attempting to register cargiver: {0}", ID));
try
{
Trace.AutoFlush = true;
string deadConnectionId;
string ConnID = Context.ConnectionId;
ConnectionDictionary.mapUidToConnection.TryRemove(ID, out deadConnectionId);
ConnectionDictionary.mapUidToConnection[ID] = ConnID;
Trace.TraceInformation(String.Format("Added caregiver: {0} connectionId {1}", ID,
ConnectionDictionary.mapUidToConnection[ID]));
Caregiver currCaregiver = CaregiverController.GetCaregiverObject(ID);
Patient currPatient = PatientController.GetPatientObjectbyGroupID(currCaregiver.GroupID);
//send patient ID to caregiver
SampleController sampleController = new SampleController();
if (SampleController.GetSampleCountforPatientID(currPatient.Id) == 0)
{
Trace.TraceInformation("No samples found for patient");
Message message = new Message()
{
ID = currPatient.Id,
status = AlgoUtils.Status.Learning,
name = "",
lat = 32.0808800F,
lon = 34.7805700F
};
Clients.Client(ConnectionDictionary.mapUidToConnection[ID]).receiveNotification(message);
WanderingAlgo algo = new WanderingAlgo();
Trace.TraceInformation("Starting Detection Algo for Patient {0} due to caregiver registration",
currPatient.Id);
algo.wanderingDetectionAlgo(currPatient.Id);
}
else
{
Sample latestSample = sampleController.GetLatestSampleForPatient(currPatient.Id);
Trace.TraceInformation("Sending message back to caregiver with patient ID");
Message message = new Message()
{
ID = currPatient.Id, status = AlgoUtils.Status.Safety, name = "", lat = latestSample.Latitude, lon = latestSample.Longitude
};
Clients.Client(ConnectionDictionary.mapUidToConnection[ID]).receiveNotification(message);
WanderingAlgo algo = new WanderingAlgo();
Trace.TraceInformation("Starting Detection Algo for Patient {0} due to caregiver registration", currPatient.Id);
algo.wanderingDetectionAlgo(currPatient.Id);
}
}
catch (Exception e)
{
Trace.TraceError("Registration of " + ID + " failed or Exception in wandering Algo: " + e.Message);
}
}
public void Initiolize(SampleController sampleController)
{
fall = false;
characterInventory = sampleController.characterInventory;
characterStatus = sampleController.characterStatus;
characterStatus.onWall = false;
cameraHandler = sampleController.cameraHandler;
anim = sampleController.anim;
}
public void Initiolize(SampleController sampleController)
{
characterController = GetComponent <CharacterController>();
characterStatus = sampleController.characterStatus;
cameraTransform = sampleController.cameraHandler.transform;
JetPack = false;
characterStatus.onWall = false;
State = sampleController.characterReactions.State;
}
public void Constructor_WhenSampleServiceIsNotNull_CreateSampleController()
{
//Arrange
SampleController sampleCtor = new SampleController(_sampleService.Object, null);
//Assert
Assert.IsNotNull(sampleCtor);
}
public void SampleController_GetUserContactsSuccess()
{
SampleController sampleController = new SampleController();
var result = sampleController.GetUserContacts() as ViewResult;
var contacts = result.ViewData.Model as List <UserContact>;
Assert.IsNotNull(contacts);
Assert.IsTrue(contacts.Count > 0);
Assert.AreEqual("Satya", contacts.FirstOrDefault().FirstName);
}
public static Boolean learningStage(string patientID)
{
int numOfSamples = SampleController.GetSampleCountforPatientID(patientID);
if (numOfSamples < 200)
{
return(true); //in learning stage
}
return(false); //not in learning stage
}
void triggerEffects()
{
FXController fXController = GameObject.Find("FX").GetComponent <FXController>();
SampleController sampleController = GameObject.Find("Audio Controller").GetComponent <SampleController>();
sampleController.playSound(SoundName.HIT);
fXController.chromaticHit();
fXController.bloomHit(10f);
}
public HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
{
HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor
{
ControllerName = "Sample",
ControllerType = typeof(SampleController)
};
Action action = new SampleController().Head;
return new ReflectedHttpActionDescriptor(controllerDescriptor, action.Method);
}
public void RedirectToAction_SameController()
{
// Act
RedirectToRouteResult result = new SampleController().RedirectToAction(x => x.SomeMethod(42));
// Assert
Assert.NotNull(result);
Assert.True("" == result.RouteName || result.RouteName.StartsWith("MethodInfo!", StringComparison.Ordinal));
Assert.Equal(3, result.RouteValues.Count);
Assert.Equal("Sample", result.RouteValues["controller"]);
Assert.Equal("SomeMethod", result.RouteValues["action"]);
Assert.Equal(42, result.RouteValues["someParameter"]);
}
public void RedirectToAction_DifferentController()
{
// Act
RedirectToRouteResult result = new SampleController().RedirectToAction<DifferentController>(x => x.SomeOtherMethod(84));
// Assert
Assert.NotNull(result);
Assert.Equal("", result.RouteName);
Assert.Equal(3, result.RouteValues.Count);
Assert.Equal("Different", result.RouteValues["controller"]);
Assert.Equal("SomeOtherMethod", result.RouteValues["action"]);
Assert.Equal(84, result.RouteValues["someOtherParameter"]);
}
public void RedirectToAction_SameController()
{
// Act
RedirectToRouteResult result = new SampleController().RedirectToAction(x => x.SomeMethod(42));
// Assert
Assert.NotNull(result);
Assert.Equal("", result.RouteName);
Assert.Equal(3, result.RouteValues.Count);
Assert.Equal("Sample", result.RouteValues["controller"]);
Assert.Equal("SomeMethod", result.RouteValues["action"]);
Assert.Equal(42, result.RouteValues["someParameter"]);
}
public void Setup()
{
_builder = new TestControllerBuilder();
_controller = _builder.CreateController<SampleController>();
ServiceLocatorInitializer.InitWithFakeDBContext();
_dbContext = SmartServiceLocator<IDbContext>.GetService();
}
public void Setup()
{
_builder = new TestControllerBuilder();
_controller = _builder.CreateController<SampleController>();
//Required by .NET4.5+ to invoke actions
System.Web.HttpContext.Current =
new System.Web.HttpContext(new System.Web.HttpRequest("foo", "http://tempuri.org/foo", ""),
new System.Web.HttpResponse(new StringWriter()));
ServiceLocatorInitializer.InitWithFakeDBContext();
_dbContext = SmartServiceLocator<IDbContext>.GetService();
_dbContext.Stub(x => x.IsActive).Repeat.Any().Return(true);
_dbContext.Stub(x => x.BeginTransaction()).Repeat.Any().WhenCalled(x => _beginTransactionCount++);
_dbContext.Stub(x => x.CommitTransaction()).Repeat.Any().WhenCalled(x => _commitTransactionCount++);
_dbContext.Stub(x => x.CloseSession()).Repeat.Any().WhenCalled(x=> _closeSessionCount++);
}
public void GetStronglyTypedParameter_Should_Throw_If_paramName_Not_In_RouteValues_Or_TempData()
{
var controller = new SampleController();
var result = controller.TestMethod();
result.GetStronglyTypedParameter(controller, "foo");
}
