public void ThenShouldReturnUnsubscribedMessage()
{
Debug.Log("Running ThenShouldReturnUnsubscribedMessage()");
receivedChannelConnectedMessage = false;
receivedUnsubscribedMessage = false;
Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenUnsubscribedToAChannel";
unitTest.TestCaseName = "ThenShouldReturnUnsubscribedMessage";
pubnub.PubnubUnitTest = unitTest;
string channel = "hello_my_channel";
pubnub.Subscribe <string>(channel, DummyMethodChannelSubscribeUserCallback, DummyMethodChannelSubscribeConnectCallback, DummyErrorCallback);
meChannelSubscribed.WaitOne();
if (receivedChannelConnectedMessage)
{
pubnub.Unsubscribe <string>(channel, DummyMethodUnsubscribeChannelUserCallback, DummyMethodUnsubscribeChannelConnectCallback, DummyMethodUnsubscribeChannelDisconnectCallback, DummyErrorCallback);
meChannelUnsubscribed.WaitOne();
}
pubnub.EndPendingRequests();
UUnitAssert.True(receivedUnsubscribedMessage, "WhenUnsubscribedToAChannel --> ThenShouldReturnUnsubscribedMessage Failed");
}
public void ThenPresenceShouldReturnCustomUUID()
{
Debug.Log("Running ThenPresenceShouldReturnCustomUUID()");
receivedCustomUUID = false;
Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenAClientIsPresented";
unitTest.TestCaseName = "ThenPresenceShouldReturnCustomUUID";
pubnub.PubnubUnitTest = unitTest;
string channel = "hello_my_channel";
pubnub.Presence <string>(channel, ThenPresenceWithCustomUUIDShouldReturnMessage, PresenceUUIDDummyMethodForConnectCallback, DummyErrorCallback);
Thread.Sleep(1000);
//since presence expects from stimulus from sub/unsub...
pubnub.SessionUUID = customUUID;
pubnub.Subscribe <string>(channel, DummyMethodForSubscribeUUID, SubscribeUUIDDummyMethodForConnectCallback, DummyErrorCallback);
Thread.Sleep(1000);
subscribeUUIDManualEvent.WaitOne(310 * 1000);
presenceUUIDManualEvent.WaitOne(310 * 1000);
pubnub.EndPendingRequests();
UUnitAssert.True(receivedCustomUUID, "Custom UUID not received");
}
public void ThenComplexMessageObjectShouldReturnSuccessCodeAndInfo()
{
Debug.Log("Running ThenComplexMessageObjectShouldReturnSuccessCodeAndInfo()");
isComplexObjectPublished = false;
Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenAMessageIsPublished";
unitTest.TestCaseName = "ThenComplexMessageObjectShouldReturnSuccessCodeAndInfo";
pubnub.PubnubUnitTest = unitTest;
string channel = "my/channel";
object message = new PubnubDemoObject();
messageComplexObjectForPublish = JsonConvert.SerializeObject(message);
//Debug.Log("Serialized message in ThenComplexMessageObjectShouldReturnSuccessCodeAndInfo() = " + messageComplexObjectForPublish);
pubnub.Publish <string>(channel, message, ReturnSuccessComplexObjectPublishCodeCallback);
mreComplexObjectPublish.WaitOne(310 * 1000);
if (!isComplexObjectPublished)
{
UUnitAssert.True(isComplexObjectPublished, "Complex Object Publish Failed");
}
else
{
pubnub.DetailedHistory <string>(channel, -1, complexObjectPublishTimetoken, -1, false, CaptureComplexObjectDetailedHistoryCallback);
mreComplexObjectDetailedHistory.WaitOne(310 * 1000);
UUnitAssert.True(isComplexObjectDetailedHistory, "Unable to match the successful unencrypt object Publish");
}
}
public void ThenSecretKeyWithEncryptPublishShouldReturnSuccessCodeAndInfo()
{
Debug.Log("Running ThenSecretKeyWithEncryptPublishShouldReturnSuccessCodeAndInfo()");
isSecretEncryptPublished = false;
Pubnub pubnub = new Pubnub("demo", "demo", "key", "enigma", false);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenAMessageIsPublished";
unitTest.TestCaseName = "ThenSecretKeyWithEncryptPublishShouldReturnSuccessCodeAndInfo";
pubnub.PubnubUnitTest = unitTest;
string channel = "my/channel";
string message = messageForSecretEncryptPublish;
pubnub.Publish <string>(channel, message, ReturnSuccessSecretEncryptPublishCodeCallback);
mreSecretEncryptPublish.WaitOne(310 * 1000);
if (!isSecretEncryptPublished)
{
UUnitAssert.True(isSecretEncryptPublished, "Secret Encrypt Publish Failed");
}
else
{
pubnub.DetailedHistory <string>(channel, -1, secretEncryptPublishTimetoken, -1, false, CaptureSecretEncryptDetailedHistoryCallback);
mreSecretEncryptDetailedHistory.WaitOne(310 * 1000);
UUnitAssert.True(isSecretEncryptDetailedHistory, "Unable to decrypt the successful Secret key Publish");
}
}
public void TestJsonLong()
{
var expectedObjects = new JsonNumTestContainer[] {
// URGENT TODO: This test fails for long.MaxValue - Write custom serializers for ulongs that can handle larger values
new JsonNumTestContainer {
IntValue = int.MaxValue, UintValue = uint.MaxValue, LongValue = long.MaxValue, UlongValue = long.MaxValue, FloatValue = float.MaxValue, DoubleValue = double.MaxValue
},
new JsonNumTestContainer {
IntValue = int.MinValue, UintValue = uint.MinValue, LongValue = long.MinValue, UlongValue = ulong.MinValue, FloatValue = float.MinValue, DoubleValue = double.MinValue
},
new JsonNumTestContainer {
IntValue = 0, UintValue = 0, LongValue = 0, UlongValue = 0, FloatValue = 0, DoubleValue = 0
},
};
for (int i = 0; i < expectedObjects.Length; i++)
{
// Convert the object to json and back, and verify that everything is the same
var actualJson = JsonConvert.SerializeObject(expectedObjects[i], Util.JsonFormatting, Util.JsonSettings).Replace(" ", "").Replace("\n", "").Replace("\r", "").Replace("\t", "");
var actualObject = JsonConvert.DeserializeObject <JsonNumTestContainer>(actualJson, Util.JsonSettings);
UUnitAssert.IntEquals(expectedObjects[i].IntValue, actualObject.IntValue);
UUnitAssert.UintEquals(expectedObjects[i].UintValue, actualObject.UintValue);
UUnitAssert.LongEquals(expectedObjects[i].LongValue, actualObject.LongValue);
UUnitAssert.ULongEquals(expectedObjects[i].UlongValue, actualObject.UlongValue);
UUnitAssert.FloatEquals(expectedObjects[i].FloatValue, actualObject.FloatValue, 0.001f);
UUnitAssert.DoubleEquals(expectedObjects[i].DoubleValue, actualObject.DoubleValue, 0.001);
}
}
public void ThenDisableJsonEncodeShouldSendSerializedObjectMessage()
{
Debug.Log("Running ThenDisableJsonEncodeShouldSendSerializedObjectMessage()");
isSerializedObjectMessagePublished = false;
Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
pubnub.EnableJsonEncodingForPublish = false;
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenAMessageIsPublished";
unitTest.TestCaseName = "ThenDisableJsonEncodeShouldSendSerializedObjectMessage";
pubnub.PubnubUnitTest = unitTest;
string channel = "hello_my_channel";
object message = "{\"operation\":\"ReturnData\",\"channel\":\"Mobile1\",\"sequenceNumber\":0,\"data\":[\"ping 1.0.0.1\"]}";
serializedObjectMessageForPublish = message.ToString();
pubnub.Publish <string>(channel, message, ReturnSuccessSerializedObjectMessageForPublishCallback, DummyErrorCallback);
mreSerializedObjectMessageForPublish.WaitOne(310 * 1000);
Thread.Sleep(1000);
if (!isSerializedObjectMessagePublished)
{
UUnitAssert.True(isSerializedObjectMessagePublished, "Serialized Object Message Publish Failed");
}
else
{
pubnub.DetailedHistory <string>(channel, -1, serializedMessagePublishTimetoken, -1, false, CaptureSerializedMessagePublishDetailedHistoryCallback, DummyErrorCallback);
mreSerializedMessagePublishDetailedHistory.WaitOne(310 * 1000);
UUnitAssert.True(isSerializedObjectMessageDetailedHistory, "Unable to match the successful serialized object message Publish");
}
}
public void nearestPointOnPlane_is_projectedVertex()
{
Debug.Log(" === known plane-projected vertex test === ");
// test point @ origin
Vector3 p = new Vector3(0, 0, 0);
// test mesh is 1x1 plane at z = 1
GameObject plane = new GameObject("testPlane");
MeshFilter mf = (MeshFilter)plane.AddComponent(typeof(MeshFilter));
Vector3[] pl = new Vector3[] { new Vector3(1, 1, 1),
new Vector3(1, -1, 1),
new Vector3(-1, 1, 1),
new Vector3(-1, -1, 1) };
mf.mesh = CreateMesh(pl);
Vector3 projection = new Vector3(0, 0, 1);
Vector3 result = NearestPointOnMesh.getNearestPointOnMesh(p, mf);
UUnitAssert.Equals(projection, result);
}
public void NoteHitShouldUpdateMorale()
{
int initialMorale = _moraleManager.GetMorale();
_scoreController.NoteHit(1);
UUnitAssert.Equals(_moraleManager.GetMorale(), initialMorale + _moraleManager._noteHit, "Morale not increased correctly");
}
public void NoteHitShouldUpdateCombo()
{
int initialCombo = _comboManager.GetCombo();
_scoreController.NoteHit(1);
UUnitAssert.Equals(_comboManager.GetCombo(), initialCombo + 1, "Combo not updated correctly");
}
public void NoteMissShouldNotUpdateScore()
{
int initialScore = _scoreManager.GetScore();
_scoreController.NoteMissed();
UUnitAssert.Equals(_scoreManager.GetScore(), initialScore, "Score updated on miss");
}
public void NoteHitShouldUpdateScore()
{
int initialScore = _scoreManager.GetScore();
_scoreController.NoteHit(100);
UUnitAssert.Equals(_scoreManager.GetScore(), initialScore + 100, "Score not updated correctly");
}
public void ThenPublishKeyShouldNotBeEmpty()
{
Debug.Log("Running ThenPublishKeyShouldNotBeEmpty()");
bool isExpectedException = false;
Pubnub pubnub = new Pubnub("", "demo", "", "", false);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenAMessageIsPublished";
unitTest.TestCaseName = "ThenPublishKeyShouldNotBeEmpty";
pubnub.PubnubUnitTest = unitTest;
string channel = "hello_my_channel";
string message = "Pubnub API Usage Example";
try
{
pubnub.Publish <string>(channel, message, null, DummyErrorCallback);
}
catch (MissingFieldException)
{
isExpectedException = true;
}
catch (Exception)
{
isExpectedException = false;
}
UUnitAssert.True(isExpectedException);
}
public void ThenUnencryptPublishShouldReturnSuccessCodeAndInfo()
{
Debug.Log("Running ThenUnencryptPublishShouldReturnSuccessCodeAndInfo()");
isUnencryptPublished = false;
Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenAMessageIsPublished";
unitTest.TestCaseName = "ThenUnencryptPublishShouldReturnSuccessCodeAndInfo";
pubnub.PubnubUnitTest = unitTest;
string channel = "hello_my_channel";
string message = messageForUnencryptPublish;
pubnub.Publish <string>(channel, message, ReturnSuccessUnencryptPublishCodeCallback, DummyErrorCallback);
mreUnencryptedPublish.WaitOne(310 * 1000);
Thread.Sleep(1000);
if (!isUnencryptPublished)
{
UUnitAssert.True(isUnencryptPublished, "Unencrypt Publish Failed");
}
else
{
pubnub.DetailedHistory <string>(channel, -1, unEncryptPublishTimetoken, -1, false, CaptureUnencryptDetailedHistoryCallback, DummyErrorCallback);
mreUnencryptDetailedHistory.WaitOne(310 * 1000);
UUnitAssert.True(isUnencryptDetailedHistory, "Unable to match the successful unencrypt Publish");
}
}
public void DetailedHistoryStartWithReverseTrue()
{
expectedCountAtStartTimeWithReverseTrue = 0;
messageStartReverseTrue = false;
Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenDetailedHistoryIsRequested";
unitTest.TestCaseName = "DetailedHistoryStartWithReverseTrue";
pubnub.PubnubUnitTest = unitTest;
string channel = "my/channel";
startTimeWithReverseTrue = Pubnub.TranslateDateTimeToPubnubUnixNanoSeconds(new DateTime(2012, 12, 1));
for (int index = 0; index < 10; index++)
{
pubnub.Publish <string>(channel,
string.Format("DetailedHistoryStartTimeWithReverseTrue {0}", index),
DetailedHistorySamplePublishCallback);
mrePublishStartReverseTrue.WaitOne();
}
Thread.Sleep(2000);
pubnub.DetailedHistory <string>(channel, startTimeWithReverseTrue, DetailedHistoryStartWithReverseTrueCallback, true);
Thread.Sleep(2000);
mreMessageStartReverseTrue.WaitOne(310 * 1000);
UUnitAssert.True(messageStartReverseTrue, "Detailed History with Start and Reverse True Failed");
}
void JsonTimeStampHandlesAllFormats()
{
string expectedJson, actualJson;
DateTime expectedTime;
ObjWithTimes actualObj = new ObjWithTimes();
for (int i = 0; i < examples.Length; i++)
{
// Define the time deserialization expectation
UUnitAssert.True(DateTime.TryParseExact(examples[i], IsoDateTimeConverter._defaultDateTimeFormats, CultureInfo.CurrentCulture, DateTimeStyles.RoundtripKind, out expectedTime), "Index: " + i + "/" + examples.Length + ", " + examples[i]);
// De-serialize the time using json
expectedJson = "{\"timestamp\":\"" + examples[i] + "\"}"; // We are provided a json string with every random time format
JsonConvert.PopulateObject(expectedJson, actualObj, Util.JsonSettings);
actualJson = JsonConvert.SerializeObject(actualObj, Util.JsonFormatting, Util.JsonSettings);
if (i == IsoDateTimeConverter.DEFAULT_UTC_OUTPUT_INDEX) // This is the only case where the json input will match the json output
{
UUnitAssert.Equals(expectedJson, actualJson);
}
// Verify that the times match
double diff = (expectedTime - actualObj.timestamp).TotalSeconds; // We expect that we have parsed the time correctly according to expectations
UUnitAssert.True(diff < 1,
"\nActual time: " + actualObj.timestamp + " vs expected time: " + expectedTime + ", diff: " + diff +
"\nActual json: " + actualJson + " vs expected json: " + expectedJson
);
}
}
public void ThenSubscribeShouldReturnReceivedMessage()
{
receivedMessage = false;
Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenSubscribedToAChannel";
unitTest.TestCaseName = "ThenSubscribeShouldReturnReceivedMessage";
pubnub.PubnubUnitTest = unitTest;
string channel = "my/channel";
pubnub.Subscribe <string>(channel, ReceivedMessageCallbackWhenSubscribed, SubscribeDummyMethodForConnectCallback);
pubnub.Publish <string>(channel, "Test for WhenSubscribedToAChannel ThenItShouldReturnReceivedMessage", dummyPublishCallback);
mePublish.WaitOne(310 * 1000);
meSubscribeNoConnect.WaitOne(310 * 1000);
pubnub.Unsubscribe <string>(channel, dummyUnsubscribeCallback, SubscribeDummyMethodForConnectCallback, UnsubscribeDummyMethodForDisconnectCallback);
meUnsubscribe.WaitOne(310 * 1000);
pubnub.EndPendingRequests();
UUnitAssert.True(receivedMessage, "WhenSubscribedToAChannel --> ThenItShouldReturnReceivedMessage Failed");
}
public void ThenMultiSubscribeShouldReturnConnectStatus()
{
receivedChannel1ConnectMessage = false;
receivedChannel2ConnectMessage = false;
Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenSubscribedToAChannel";
unitTest.TestCaseName = "ThenMultiSubscribeShouldReturnConnectStatus";
pubnub.PubnubUnitTest = unitTest;
string channel1 = "my/channel1";
pubnub.Subscribe <string>(channel1, ReceivedChannelUserCallback, ReceivedChannel1ConnectCallback);
meChannel1SubscribeConnect.WaitOne(310 * 1000);
string channel2 = "my/channel2";
pubnub.Subscribe <string>(channel2, ReceivedChannelUserCallback, ReceivedChannel2ConnectCallback);
meChannel2SubscribeConnect.WaitOne(310 * 1000);
pubnub.EndPendingRequests();
UUnitAssert.True(receivedChannel1ConnectMessage && receivedChannel2ConnectMessage, "WhenSubscribedToAChannel --> ThenSubscribeShouldReturnConnectStatus Failed");
}
public void ThenPubnubShouldGenerateUniqueIdentifier()
{
Debug.Log("Running ThenPubnubShouldGenerateUniqueIdentifier()");
Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
UUnitAssert.NotNull(pubnub.GenerateGuid());
}
public void ThenDuplicateChannelShouldReturnAlreadySubscribed()
{
receivedAlreadySubscribedMessage = false;
Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenSubscribedToAChannel";
unitTest.TestCaseName = "ThenDuplicateChannelShouldReturnAlreadySubscribed";
pubnub.PubnubUnitTest = unitTest;
string channel = "my/channel";
pubnub.Subscribe <string>(channel, DummyMethodDuplicateChannelUserCallback1, DummyMethodDuplicateChannelConnectCallback);
Thread.Sleep(100);
pubnub.Subscribe <string>(channel, DummyMethodDuplicateChannelUserCallback2, DummyMethodDuplicateChannelConnectCallback);
meAlreadySubscribed.WaitOne();
pubnub.EndPendingRequests();
UUnitAssert.True(receivedAlreadySubscribedMessage, "WhenSubscribedToAChannel --> ThenDuplicateChannelShouldReturnAlreadySubscribed Failed");
}
public void ThenPresenceShouldReturnReceivedMessage()
{
Debug.Log("Running ThenPresenceShouldReturnReceivedMessage()");
receivedPresenceMessage = false;
Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenAClientIsPresented";
unitTest.TestCaseName = "ThenPresenceShouldReturnReceivedMessage";
pubnub.PubnubUnitTest = unitTest;
string channel = "my/channel";
pubnub.Presence <string>(channel, ThenPresenceShouldReturnMessage, PresenceDummyMethodForConnectCallback);
Thread.Sleep(1000);
//since presence expects from stimulus from sub/unsub...
pubnub.Subscribe <string>(channel, DummyMethodForSubscribe, SubscribeDummyMethodForConnectCallback);
Thread.Sleep(1000);
subscribeManualEvent.WaitOne(2000);
pubnub.Unsubscribe <string>(channel, DummyMethodForUnSubscribe, UnsubscribeDummyMethodForConnectCallback, UnsubscribeDummyMethodForDisconnectCallback);
Thread.Sleep(1000);
unsubscribeManualEvent.WaitOne(2000);
presenceManualEvent.WaitOne(310 * 1000);
pubnub.EndPendingRequests();
UUnitAssert.True(receivedPresenceMessage, "Presence message not received");
}
public void ThenEncryptObjectPublishShouldReturnSuccessCodeAndInfo()
{
Debug.Log("Running ThenEncryptObjectPublishShouldReturnSuccessCodeAndInfo()");
isEncryptObjectPublished = false;
Pubnub pubnub = new Pubnub("demo", "demo", "", "enigma", false);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenAMessageIsPublished";
unitTest.TestCaseName = "ThenEncryptObjectPublishShouldReturnSuccessCodeAndInfo";
pubnub.PubnubUnitTest = unitTest;
string channel = "hello_my_channel";
object message = new SecretCustomClass();
messageObjectForEncryptPublish = new JsonFXDotNet().SerializeToJsonString(message);
pubnub.Publish <string>(channel, message, ReturnSuccessEncryptObjectPublishCodeCallback, DummyErrorCallback);
mreEncryptObjectPublish.WaitOne(310 * 1000);
Thread.Sleep(1000);
if (!isEncryptObjectPublished)
{
UUnitAssert.True(isEncryptObjectPublished, "Encrypt Object Publish Failed");
}
else
{
pubnub.DetailedHistory <string>(channel, -1, encryptObjectPublishTimetoken, -1, false, CaptureEncryptObjectDetailedHistoryCallback, DummyErrorCallback);
mreEncryptObjectDetailedHistory.WaitOne(310 * 1000);
UUnitAssert.True(isEncryptObjectDetailedHistory, "Unable to match the successful encrypt object Publish");
}
}
void TestSetUp()
{
TestCaseDummy local = new TestCaseDummy("TestMethod");
local.Run();
UUnitAssert.True(local.wasSetUp, "wasSetUp");
UUnitAssert.Equals(local.log, "setUp ", "setup");
}
void GetSceneTypeCallback(string res)
{
JsonData jd = JsonMapper.ToObject(res);
SceneType sceneType = new SceneType((int)(jd[Param.TYPE_ID]), (string)(jd[Param.NAME]), (string)jd[Param.PICTURE_ID],
StringUtil.StringToDateTime((string)(jd[Param.MODIFIED])));
UUnitAssert.Equals(100001, sceneType.typeId);
}
public void TranslateUnixTimeToDateTime()
{
//Test for 26th June 2012 GMT
DateTime expectedDate = new DateTime(2012, 6, 26, 0, 0, 0, DateTimeKind.Utc);
DateTime actualDate = Pubnub.TranslatePubnubUnixNanoSecondsToDateTime(13406688000000000);
UUnitAssert.Equals(expectedDate.ToString(), actualDate.ToString());
}
public void TranslateDateTimeToUnixTime()
{
//Test for 26th June 2012 GMT
DateTime dt = new DateTime(2012, 6, 26, 0, 0, 0, DateTimeKind.Utc);
long nanoSecondTime = Pubnub.TranslateDateTimeToPubnubUnixNanoSeconds(dt);
UUnitAssert.Equals(13406688000000000, nanoSecondTime);
}
public void HealthShouldDecreaseWhenDamageTaken()
{
int damageAmount = 10;
int initialHealth = _playerHealthManager.GetHealth();
_playerHealthManager.TakeDamage(damageAmount);
UUnitAssert.Equals(_playerHealthManager.GetHealth(), initialHealth - damageAmount, "Health not decreased correctly");
}
public void TestRunning()
{
TestCaseDummy local = new TestCaseDummy("TestMethod");
UUnitAssert.False(local.wasRun, " not wasRun");
local.Run();
UUnitAssert.True(local.wasRun, "wasRun");
}
public void NoteMissShouldReduceMorale()
{
int initialMorale = 50;
_moraleManager.SetMorale(initialMorale);
_scoreController.NoteMissed();
UUnitAssert.Equals(_moraleManager.GetMorale(), initialMorale - _moraleManager._noteMiss, "Morale not decreased by right amount after note miss");
}
public void constructorShouldCreateADefinedGrid()
{
FieldLogic underTest = new FieldLogic(1, 3);
UUnitAssert.Equals(1, underTest.getWidth());
UUnitAssert.Equals(3, underTest.getHeight());
UUnitAssert.Null(underTest.CellAt(0, 2));
}
public void TestTestSuiteAddAll()
{
UUnitTestSuite suite = new UUnitTestSuite();
suite.AddAll(typeof(TestCaseDummy));
UUnitTestResult result = suite.Run();
UUnitAssert.Equals("2 run, 1 failed", result.Summary(), "Suite");
}
