public ActionResult Index()
{
var permissions = Scientist.Science <IEnumerable <Permission> >("Permissions", experiment =>
{
experiment.Compare((x, y) => x.SequenceEqual(y));
experiment.Use(() => db.GetApplicationPermissionsV1().ToList());
experiment.Try(() => db.GetApplicationPermissionsV3().ToList());
});
return(View(permissions));
}
public void AllowsReturningNullFromControlOrTest()
{
var result = Scientist.Science <object>("failure", experiment =>
{
experiment.Use(() => null);
experiment.Try(() => null);
});
Assert.Null(result);
Assert.True(TestHelper.Observation.First(m => m.Name == "failure").Success);
}
public void AddScientist(Scientist s)
{
if (Db.Query <Scientist> ("Select * from Scientist where id = " + s.Id).Count > 0)
{
Db.Update(s);
}
else
{
Db.Insert(s);
}
}
public async Task PublishesAsynchronously()
{
const int expectedResult = 42;
var pendingPublishTask = new TaskCompletionSource <object>();
// Create a new publisher that will delay all
// publishing to account for this test.
var innerPublisher = Substitute.For <IResultPublisher>();
innerPublisher.Publish(Arg.Any <Result <int, int> >())
.Returns(call => pendingPublishTask.Task);
var fireAndForgetPublisher = new FireAndForgetResultPublisher(innerPublisher, ex => { });
var mock = Substitute.For <IControlCandidate <int, string> >();
mock.Control().Returns(expectedResult);
mock.Candidate().Returns(expectedResult);
const int count = 10;
using (Swap.Publisher(fireAndForgetPublisher))
{
Parallel.ForEach(
Enumerable.Repeat(0, count),
src =>
{
var result = Scientist.Science <int>("myExperiment", experiment =>
{
experiment.Use(mock.Control);
experiment.Try(mock.Candidate);
});
Assert.Equal(expectedResult, result);
});
}
// Make sure that the above science calls are still publishing.
Task whenPublished = fireAndForgetPublisher.WhenPublished();
Assert.NotNull(whenPublished);
// Ensure that the mock was called before the when published task has completed.
mock.Received(count).Control();
mock.Received(count).Candidate();
Assert.False(whenPublished.IsCompleted, "When Published Task completed early.");
pendingPublishTask.SetResult(null);
await whenPublished;
Assert.True(whenPublished.IsCompleted, "When Published Task isn't complete.");
}
public static bool IsMeme(string phrase)
{
return(Scientist.Science <bool>("adding-context-example", experiment => {
// If you add context here...
experiment.AddContext("phrase", phrase);
experiment.AddContext("when", DateTimeOffset.Now);
experiment.Use(() => MemeBot2000.IsMeme(phrase)); // Control
experiment.Try(() => MemeBot3000.IsMeme(phrase)); // Candidate
}));
}
public async Task <IActionResult> PostScientist([FromBody] Scientist scientist)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Scientist.Add(scientist);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetScientist", new { id = scientist.Id }, scientist));
}
public void AllowsReturningNullFromControlOrTest()
{
const string experimentName = nameof(AllowsReturningNullFromControlOrTest);
var result = Scientist.Science <object>(experimentName, experiment =>
{
experiment.Use(() => null);
experiment.Try("candidate", () => null);
});
Assert.Null(result);
Assert.True(TestHelper.Results <object>(experimentName).First().Matched);
}
public void ResetFields()
{
if (FieldsAreNull())
{
InitializeFields();
}
name.Text = "";
desc.Text = "";
image.SetImageResource(Resource.Drawable.placeholder);
s = null;
//ImageService.LoadFile(animalAndroid.Uri).DownSample(image.Width, image.Height).Into(image);
}
private static int GetResultWithScientist(int randomInput)
{
int result = Scientist.Science <int>("First experiment", experiment =>
{
experiment.AddContext("Random Data", randomInput);
experiment.Use(() => new ComplicatedCalc_V1().GetResult(randomInput)); // Old Version
experiment.Try(() => new ComplicatedCalc_V2().GetResult(randomInput)); // New Version
});
return(result);
}
public static bool IsMeme(string phrase)
{
// Runs and returns the control
// Runs the experiment as well (but does not return it)
// Note! This doesn't actually output or record anything about the experiment.
// To see how that's done, look at 02-RecordingResultsExample.cs.
return(Scientist.Science <bool>("basic-example", experiment => {
experiment.Use(() => MemeBot2000.IsMeme(phrase)); // Control
experiment.Try(() => MemeBot3000.IsMeme(phrase)); // Candidate
}));
}
public void NoCandidateMeansNoPublish()
{
const string experimentName = "noCandidateNoPublish";
var result = Scientist.Science <int>(experimentName, experiment =>
{
experiment.Use(() => 42);
});
// verify that no results were published for this experiment
Assert.Empty(TestHelper.Results <int>(experimentName));
}
public InventoryResult Post([FromBody] Inventory value)
{
Scientist.ResultPublisher = new MyResultPublisher();
return(Scientist.Science <InventoryResult>("VatIsCorrect", experiment =>
{
experiment.Compare((x, y) => x.TotalPrice == y.TotalPrice);
experiment.Use(() => _vatService.Result(value)); // old way
experiment.Try(() => _vatService.NewResults(value)); // new way
}));
}
public static bool IsMeme(string phrase)
{
return(Scientist.Science <bool>("sampling-example", experiment => {
experiment.AddContext("phrase", phrase);
experiment.AddContext("when", DateTimeOffset.Now);
// Let's say we only want to run the experiment 50% of the time
experiment.RunIf(() => rng.Next(10) < 5);
experiment.Use(() => MemeBot2000.IsMeme(phrase)); // Control
experiment.Try(() => MemeBot3000.IsMeme(phrase)); // Candidate
}));
}
public static bool IsMeme(string phrase)
{
return(Scientist.Science <bool>("conditional-example", experiment => {
experiment.AddContext("phrase", phrase);
experiment.AddContext("when", DateTimeOffset.Now);
// Let's say we only want to run the experiment if people are excited.
// This means the experiment will only run when the phrase ends with an bang (!)
experiment.RunIf(() => !string.IsNullOrWhiteSpace(phrase) && phrase.EndsWith('!'));
experiment.Use(() => MemeBot2000.IsMeme(phrase)); // Control
experiment.Try(() => MemeBot3000.IsMeme(phrase)); // Candidate
}));
}
// GET: Scientists/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Scientist scientist = db.Scientists.Find(id);
if (scientist == null)
{
return(HttpNotFound());
}
return(View(scientist));
}
public void Post_Creates_New_Scientist()
{
var newScientist = new Scientist(1, "New scientist");
var scientistList = new List <Scientist>();
scientistRepo.When(t => t.Create(newScientist))
.Do(t => scientistList.Add(newScientist));
scientistRepo.GetAll().Returns(scientistList);
var result = underTest.Post(newScientist);
Assert.Contains(newScientist, result);
}
public void NoCandidateMeansRunIfIsNeverRun()
{
var mock = Substitute.For <IControlCandidate <int> >();
mock.RunIf().Returns(false);
Scientist.Science <int, int>("noCandidateNoRunIf", experiment =>
{
experiment.Use(() => 42);
experiment.RunIf(mock.RunIf);
});
mock.DidNotReceive().RunIf();
}
public void NoCandidateMeansCleanIsNeverRun()
{
var mock = Substitute.For <IControlCandidate <int, int> >();
mock.Clean(Arg.Any <int>()).Returns(0);
Scientist.Science <int, int>("noCandidateNoClean", experiment =>
{
experiment.Use(() => 42);
experiment.Clean(mock.Clean);
});
mock.DidNotReceive().Clean(Arg.Any <int>());
}
public void GetAnimalData()
{
uri = animalAndroid.Uri;
id = animalAndroid.id;
name.Text = animalAndroid.name;
desc.Text = animalAndroid.desc;
ImageService.LoadFile(animalAndroid.Uri).DownSample(100, 100).Into(image);
var listaNombres = DataManager.Instance.GetScientistNames(id);
var adapter = new ArrayAdapter <String> (this.Activity, Resource.Layout.support_simple_spinner_dropdown_item, listaNombres);
listaScient = DataManager.Instance.GetScientist(animalAndroid.id);
var listaNames = DataManager.Instance.GetScientistNamesFromAnimal(animalAndroid.id);
s = null;
}
public IEnumerable <DataWithSomeSensitiveStuff> Get()
{
return(Scientist.Science <
IEnumerable <DataWithSomeSensitiveStuff>,
IEnumerable <DataWithSomeSensitiveStuff> >(
"sensitive-stuff", experiment =>
{
experiment.Compare(CompareOriginalAndNewResults);
experiment.AddContext("request id", Guid.NewGuid());
experiment.Use(OriginalGetStuff);
experiment.Try(NewGetStuff);
experiment.Clean(dirty => dirty.Select(SanitiseForReporting));
}));
}
public async Task OnPost()
{
HasResult = true;
Position = FibonacciInput.Position;
Result = await Scientist.ScienceAsync <int>("fibonacci-implementation", experiment =>
{
experiment.Use(async() => await _recursiveFibonacciCalculator.CalculateAsync(Position));
experiment.Try(async() => await _linearFibonacciCalculator.CalculateAsync(Position));
experiment.AddContext("Position", Position);
});
LastResults = _experimentResultsGetter.LastResults;
OverallResults = _experimentResultsGetter.OverallResults;
}
public void NoCandidateMeansNoDisable()
{
var settings = Substitute.For <IScientistSettings>();
settings.Enabled().Returns(Task.FromResult(false));
using (Swap.Enabled(settings.Enabled))
{
Scientist.Science <int>("noCandidateNoDisable", experiment =>
{
experiment.Use(() => 42);
});
settings.DidNotReceive().Enabled();
}
}
static void Main(string[] args)
{
//Example for dictionary:
Project p0 = new Project("C#", 100000);
Project p1 = new Project("Bitcoins", 5000000);
var s0 = new Scientist("Vera", "Musterfrau", 60000, "Dr");
s0.Projects.Add(p0);
s0.Projects.Add(p1);
var projectEmployees = new List <Employee>
{
new ExternalLecturer("Peter", "Müller", 40000),
new Assistant("Hans", "Hansen", 30000, 40, p0),
s0
};
var dict = GetProjectEmployees(projectEmployees);
//Print those employees working on project "C#":
var cSharpEmployees = dict[p0];
Console.WriteLine("Employees on the C# project:");
foreach (Employee e in cSharpEmployees)
{
Console.WriteLine(e);
}
//Example for withdrawing money:
Project testProject = new Project("C#", 100000);
ProjectStaff a = new ProjectStaff("Fritz", "Müller", 20000, testProject);
testProject.WithdrawMoney(10000, a);
//Example for ITeach interface:
List <ITeach> teachers = new List <ITeach>
{
new Scientist("Hans", "Petersen", 40000, "Dr"),
new ExternalLecturer("Günther", "Hansen", 30000)
};
foreach (ITeach teacher in teachers)
{
teacher.Teaching(); //Polymorphism
}
}
public static void RemoveScientist(Conference conference, Scientist scientist)
{
try
{
using (ApplicationContext db = new ApplicationContext())
{
Conference con = (from c in db.Conferences where c.Id == conference.Id select c).Include(c => c.ScientistConference).First();
ScientistConference sco = con.ScientistConference.First(sc => sc.ScientistId == scientist.Id);
con.ScientistConference.Remove(sco);
db.SaveChanges();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public static void RemoveScientist(Organization organization, Scientist scientist)
{
try
{
using (ApplicationContext db = new ApplicationContext())
{
Organization org = (from o in db.Organizations where o.Id == organization.Id select o).Include(o => o.ScientistOrganization).First();
ScientistOrganization so = org.ScientistOrganization.First(so => so.ScientistId == scientist.Id);
org.ScientistOrganization.Remove(so);
db.SaveChanges();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task RunsBothBranchesOfSimpleAsynchronousExperimentAndReportsFailure()
{
const string experimentName = nameof(RunsBothBranchesOfSimpleAsynchronousExperimentAndReportsFailure);
var resultPublisher = new InMemoryResultPublisher();
var science = new Scientist(resultPublisher);
var result = await science.ExperimentAsync <int>(experimentName, experiment =>
{
experiment.Use(() => Task.FromResult(42));
experiment.Try(() => Task.FromResult(37));
});
Assert.Equal(42, result);
Assert.False(resultPublisher.Results <int>(experimentName).First().Matched);
Assert.True(resultPublisher.Results <int>(experimentName).First().Mismatched);
}
public ActionResult Edit([Bind(Include = "ID,Name,Title,Department,Mail,Phone,City,ImgName")] Scientist scientist, HttpPostedFileBase imgname)
{
if (ModelState.IsValid)
{
UpdateModel(scientist);
if (imgname != null && imgname.ContentLength > 0)
{
scientist.ImgName = imgname.FileName;
imgname.SaveAs(HttpContext.Server.MapPath("~/Images/") + scientist.ImgName);
}
db.Entry(scientist).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(scientist));
}
public void RunsBeforeRun()
{
var mock = Substitute.For <IControlCandidate <int> >();
mock.Control().Returns(42);
mock.Candidate().Returns(42);
const string experimentName = nameof(RunsBeforeRun);
var result = Scientist.Science <int>(experimentName, experiment =>
{
experiment.BeforeRun(mock.BeforeRun);
experiment.Use(mock.Control);
experiment.Try("candidate", mock.Candidate);
});
Assert.Equal(42, result);
mock.Received().BeforeRun();
}
public void NoCandidateStillRunsControl()
{
const int expectedResult = 42;
var mock = Substitute.For <IControlCandidate <int> >();
mock.Control().Returns(expectedResult);
const string experimentName = "noCandidate";
var result = Scientist.Science <int>(experimentName, experiment =>
{
experiment.Use(mock.Control);
});
Assert.Equal(expectedResult, result);
mock.Received().Control();
}
public static void AddScientist(Conference conference, Scientist scientist)
{
try
{
using (ApplicationContext db = new ApplicationContext())
{
Conference con = (from c in db.Conferences where c.Id == conference.Id select c).First();
con.ScientistConference.Add(new ScientistConference {
ConferenceId = conference.Id, ScientistId = scientist.Id
});
db.SaveChanges();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
void Awake()
{
S = this;
currHP = MaxHP;
}