public static Entity PlaceRandom(Vector2 where, Area area)
{
try {
var chest = (Chest)Activator.CreateInstance(Instance.Generate());
if (!(chest is GlassChest || chest is ProtoChest) && Rnd.Chance(LevelSave.MimicChance))
{
var mimic = new Mimic {
Kind = chest.GetSprite(),
Pool = chest.GetPool()
};
area.Add(mimic);
mimic.BottomCenter = where;
return(mimic);
}
area.Add(chest);
chest.BottomCenter = where;
return(chest);
} catch (Exception ex) {
Log.Error(ex);
}
return(null);
}
public void CacheProxyRecordsException()
{
var exception = new CustomException();
var repo = new FakeRepositoryThrows(exception);
var source = Mimic.Cache <IFakeRepository>(repo, new History());
try
{
source.ParameterlessFn();
Assert.Fail("Expect CustomException");
}
catch (CustomException)
{
}
var log = Mimic.GetHistory(source);
var testee = Mimic.Stub <IFakeRepository>(log);
try
{
testee.ParameterlessFn();
Assert.Fail();
}
catch (CustomException e)
{
}
catch (Exception e)
{
Assert.Fail();
}
}
public void CanSerialiseExceptionInHistoryLog()
{
var exception = new CustomException();
var repo = new FakeRepositoryThrows(exception);
var source = Mimic.Record <IFakeRepository>(repo);
try
{
source.ParameterlessFn();
Assert.Fail("Expect CustomException");
}
catch (CustomException)
{
}
var logSerialised = Mimic.SerialiseHistory(source);
var testee = Mimic.Stub <IFakeRepository>(Mimic.DeserialiseHistory(logSerialised));
try
{
testee.ParameterlessFn();
Assert.Fail();
}
catch (CustomException e)
{
}
catch (Exception e)
{
Assert.Fail();
}
}
public void ReplayerShouldThrowWhenCreatedWithoutSpecifyingAnInterface()
{
var repo = new FakeRepositorySquares();
var recorder = Mimic.Record <IFakeRepository>(repo);
var replayer = Mimic.Stub <FakeRepositorySquares>(Mimic.GetHistory(recorder));
}
public IActionResult Feed(int mimicId)
{
int?UserId = HttpContext.Session.GetInt32("UserId");
if (UserId != null)
{
User currentUser = _context.users.SingleOrDefault(u => u.id == UserId);
Mimic currentMimic = _context.mimics.Include(m => m.owner).SingleOrDefault(m => m.id == mimicId);
if (currentMimic.owner.food <= 0)
{
return(View("Error"));
}
else
{
currentMimic.hunger += 1;
currentUser.food -= 1;
_context.SaveChanges();
return(RedirectToAction("mimic", new { currentMimic.id }));
}
}
else
{
return(View("Notlogged"));
}
}
public void CacheProxyReplaysException()
{
var exceptionMessage = "message";
var exception = new CustomException(exceptionMessage);
var repo = new FakeRepositoryThrows(exception);
var source = Mimic.Record <IFakeRepository>(repo);
try
{
source.ParameterlessFn();
Assert.Fail("Expect CustomException");
}
catch (CustomException)
{
}
var log = Mimic.GetHistory(source);
var otherRepo = new FakeRepositoryDoubles();
var testee = Mimic.Cache <IFakeRepository>(otherRepo, log);
try
{
testee.ParameterlessFn();
Assert.Fail();
}
catch (CustomException e)
{
}
catch (Exception e)
{
Assert.Fail();
}
}
public void CacheProxyPassesUncachedCallsToTheBaseType_WhenCheckingNULL()
{
var data = new DataStructure {
Age = 21, Name = "Jimmy"
};
var returnValue = new DataStructure {
Age = 22, Name = "Janey"
};
var returnValue2 = new DataStructure {
Age = 11, Name = "Jimbo"
};
var repo = new ComplexRepositoryReturnsWhateverItWasSetupWith(returnValue);
var recorder = Mimic.Record <IComplexRepository>(repo);
DataStructure firstResult = recorder.GetRelated(data);
string serialisedHistory = Mimic.SerialiseHistory(recorder);
var history = Mimic.DeserialiseHistory(serialisedHistory);
var replayer = Mimic.Cache <IComplexRepository>(
new ComplexRepositoryReturnsWhateverItWasSetupWith(returnValue2), history);
DataStructure result = replayer.GetRelated(null);
Assert.AreEqual(returnValue2.Name, result.Name, "otherwise this is because it was cached");
Assert.AreEqual(returnValue2.Age, result.Age, "otherwise this is because it was cached");
}
public void DerivedReturnValue_WhenMatchesExpectation()
{
var ds = new DataStructure()
{
Age = 13, Name = "jimbob"
};
var repo = new ComplexRepositoryReturnsWhateverItWasSetupWith(
new DerivedDataStructure()
{
Balance = 2
});
var recorder = Mimic.Record <IComplexRepository>(repo);
recorder.GetRelated(ds);
History history = Mimic.GetHistory(recorder);
var testee = Mimic.GetBehaviourVerifier(history);
var result = testee.ConfirmBehaviourHasNotChanged(
new ComplexRepositoryReturnsWhateverItWasSetupWith(
new DerivedDataStructure()
{
Balance = 2
}));
Assert.IsTrue(result);
}
private static IFakeRepository GivenIExpect_WhenIObserveBehaviour(Action <IFakeRepository> expected,
Action <IFakeRepository> observed, bool caching = false)
{
var repo = new FakeRepositorySquares();
var recorder = Mimic.Record <IFakeRepository>(repo);
try
{
expected(recorder);
}
catch (Exception)
{
}
string serialised = Mimic.SerialiseHistory(recorder);
var log = Mimic.DeserialiseHistory(serialised);
var verifier = caching ?
Mimic.Cache <IFakeRepository>(new FakeRepositorySquares(), log)
: Mimic.Stub <IFakeRepository>(log);
try
{
observed(verifier);
}
catch (Exception)
{
}
return(verifier);
}
static void Main(string[] args)
{
var mimic = new Mimic <IClient, RealWorker>();
var instance = mimic.NewInstance(new RealWorker());
instance.Foo("pickle-pee", "pump-a-rum", 42);
}
// Use this for initialization
void Start()
{
int halfX = (int)(mimicDimensions.x / 2);
int halfY = (int)(mimicDimensions.y / 2);
int halfZ = (int)(mimicDimensions.z / 2);
for (int k = 0; k < mimicDimensions.z; k++)
{
float zOffset = spacing * (k - halfZ);
for (int j = 0; j < mimicDimensions.y; j++)
{
float yOffset = spacing * (j - halfY);
for (int i = 0; i < mimicDimensions.x; i++)
{
if ((i == halfX) && (j == halfY) && (k == halfZ))
{
continue;
}
float xOffset = spacing * (i - halfX);
GameObject mimic = CreateMimic();
Vector3 offset = new Vector3(xOffset, yOffset, zOffset);
Mimic mimicScript = mimic.GetComponent <Mimic>();
mimicScript.offset = offset;
mimicScript.target = gameObject.transform;
}
}
}
}
public void HiddenMethodsAndHidingMethodsShouldHaveTheirBehaviourCorrectlyVerified_WhenBehaviourIsNotAsExpected()
{
var repo = new HidingDerivedMultipliesByX()
{
X = 3, Y = 1
};
var proxy = Mimic.Record <IHidingDerivedTriples>(repo);
var answer1 = proxy.Function(3);
var answer2 = ((IHiddenBaseMultipliesByY)proxy).Function(3);
var history = Mimic.GetHistory(proxy);
var repoBehavesAsExpected = new HidingDerivedMultipliesByX()
{
X = 2, Y = 1
};
var verifier = Mimic.GetBehaviourVerifier(history);
var result = verifier.ConfirmBehaviourHasNotChanged(repoBehavesAsExpected);
Assert.IsFalse(result);
var repoBehavesAsExpected2 = new HidingDerivedMultipliesByX()
{
X = 3, Y = 2
};
var verifier2 = Mimic.GetBehaviourVerifier(history);
var result2 = verifier.ConfirmBehaviourHasNotChanged(repoBehavesAsExpected2);
Assert.IsFalse(result2);
}
public void EmptyHistoryVerifiesOK()
{
var history = new History();
var testee = Mimic.GetBehaviourVerifier(history);
var result = testee.ConfirmBehaviourHasNotChanged(new FakeRepositorySquares());
Assert.IsTrue(result);
}
public static IServiceCollection AddScopedMimic <TInterface, TProtocol>(this IServiceCollection provider)
where TProtocol : IMimicWorker
{
var mimic = new Mimic <TInterface, TProtocol>();
provider.AddScoped(typeof(TInterface), mimic.Type);
return(provider);
}
public void ConstructMimicNoMultiplierOffset()
{
Mimic mimic = new Mimic(TEST_JOINT);
Assert.AreEqual(TEST_JOINT, mimic.Joint);
Assert.AreEqual(1, mimic.Multiplier);
Assert.AreEqual(0, mimic.Offset);
}
public void RecorderProxyBubblesException()
{
var exception = new CustomException();
var repo = new FakeRepositoryThrows(exception);
var testee = Mimic.Record <IFakeRepository>(repo);
testee.ParameterlessFn();
}
public void ReplayProxy_Throws_WhenNoMatchingCallIsPresent()
{
var repo = new FakeRepositorySquares();
var recorder = Mimic.Record <IFakeRepository>(repo);
var replayer = Mimic.Stub <IFakeRepository>(Mimic.GetHistory(recorder));
int result = replayer.Function(3);
}
public void RecorderShouldActAsAProxy()
{
var repo = new FakeRepositorySquares();
var testee = Mimic.Record <IFakeRepository>(repo);
int result = testee.Function(3);
Assert.AreEqual(9, result);
}
public override void Spawn(Transform transform)
{
GameObject go = Object.Instantiate(ModelPrefab, transform, true);
Mimic mimic = go.GetComponent <Mimic>();
_animator = mimic.Animator;
_light = mimic.InsideLight;
//_anim.SetBool("Open", true);
}
public void ValTypeReturn()
{
var tiMimic = new Mimic <ITestInterface, MockImpl>().NewInstance(new MockImpl());
var sc = new SimpleClass();
var inVal = tiMimic.ValInt(sc, "", 42);
Assert.Equal(inVal, 42);
}
public void VerifierProxy_AssertsFailByDefault_WhenSameCallIsMadeAndObservedMoreTimes()
{
var verifier = GivenIExpect_WhenIObserveBehaviour(
expected: (repo) => { repo.Function(2); repo.Function(2); },
observed: (repo) => { repo.Function(2); repo.Function(2); repo.Function(2); });
var result = Mimic.ConfirmSameCallsWereMade(verifier);
Assert.IsFalse(result);
}
public void VerifierProxy_AssertsPass_WhenAdditionalCallsAreAllowedAndAreObservedIncludingOnesMatchingParams()
{
var verifier = GivenIExpect_WhenIObserveBehaviour_WithCaching(
expected: (repo) => { repo.Function(2); repo.Function(3); },
observed: (repo) => { repo.Function(3); repo.Function(2); repo.Function(3); });
var result = Mimic.ConfirmSameCallsWereMade(verifier, MockOptions.AllExpectedCallsMustBeObserved | MockOptions.CallsMustOccurInTheExactSameOrder);
Assert.IsTrue(result);
}
public void VerifierProxy_AssertsOk_WhenSameCallIsMadeAndObservedMoreTimes_AndNumberDoesNotMatter()
{
var verifier = GivenIExpect_WhenIObserveBehaviour(
expected: (repo) => { repo.Function(2); repo.Function(2); },
observed: (repo) => { repo.Function(2); repo.Function(2); repo.Function(2); });
var result = Mimic.ConfirmSameCallsWereMade(verifier, MockOptions.Default_SameCallsSameNumberOfTimesInAnyOrder ^ MockOptions.ExpectedCallsMustBeObservedTheExactNumberOfTimes);
Assert.IsTrue(result);
}
public void VerifierProxy_AssertsFail_WhenOrderIsSpecified_AndCallsAreObservedInTheWrongOrder()
{
var verifier = GivenIExpect_WhenIObserveBehaviour(
expected: (repo) => { repo.Function(-1); repo.Function(2); },
observed: (repo) => { repo.Function(2); repo.Function(-1); });
var result = Mimic.ConfirmSameCallsWereMade(verifier, MockOptions.CallsMustOccurInTheExactSameOrder);
Assert.IsFalse(result);
}
public void VerifierProxy_AssertsPass_WhenNumberOfCallsDoesNotMatterAndVariesLower()
{
var verifier = GivenIExpect_WhenIObserveBehaviour_WithCaching(
expected: (repo) => { repo.Function(2); repo.Function(2); repo.Function(3); repo.Function(2); repo.Function(3); },
observed: (repo) => { repo.Function(3); repo.Function(2); });
var result = Mimic.ConfirmSameCallsWereMade(verifier, MockOptions.AllExpectedCallsMustBeObserved | MockOptions.OnlyExpectedCallsAreAllowed);
Assert.IsTrue(result);
}
public void VerifierProxy_AssertsFail_WhenOneCallsIsExpectedAndNoneIsMade()
{
var verifier = GivenIExpect_WhenIObserveBehaviour(
expected: (repo) => { repo.Function(3); },
observed: (repo) => {; });
var result = Mimic.ConfirmSameCallsWereMade(verifier);
Assert.IsFalse(result);
}
public void VerifierProxy_AssertsPass_ForAnEmptyCallList()
{
var verifier = GivenIExpect_WhenIObserveBehaviour(
expected: (repo) => {; },
observed: (repo) => {; });
var result = Mimic.ConfirmSameCallsWereMade(verifier);
Assert.IsTrue(result);
}
public void VerifierProxy_AssertsPass_WhenTwoCallsAreExpectedAndAreMade_InEitherOrder()
{
var verifier = GivenIExpect_WhenIObserveBehaviour(
expected: (repo) => { repo.Function(-1); repo.Function(2); },
observed: (repo) => { repo.Function(2); repo.Function(-1); });
var result = Mimic.ConfirmSameCallsWereMade(verifier);
Assert.IsTrue(result);
}
public void ConstructMimic()
{
double multiplier = 10;
double offest = 10;
Mimic mimic = new Mimic(TEST_JOINT, multiplier, offest);
Assert.AreEqual(TEST_JOINT, mimic.Joint);
Assert.AreEqual(TEST_JOINT.Name, mimic.Joint.Name);
Assert.AreEqual(multiplier, mimic.Multiplier);
Assert.AreEqual(offest, mimic.Offset);
}
public void Cast()
{
dynamic mimic = new Mimic();
int Int32 = mimic;
double Double = mimic;
float Float = mimic;
object Object = mimic;
Guid Guid = mimic;
DateTime DateTime = mimic;
}
