public void ThenItShouldReturnReceivedMessageForComplexMessage ()
{
Pubnub pubnub = new Pubnub (
"demo",
"demo",
"",
"",
false);
string channel = "hello_world";
Common common = new Common();
common.DeliveryStatus = false;
common.Response = null;
pubnub.PubnubUnitTest = common.CreateUnitTestInstance("WhenSubscribedToAChannel", "ThenItShouldReturnReceivedMessageForComplexMessage");
pubnub.Subscribe (channel, common.DisplayReturnMessage, common.DisplayReturnMessageDummy);
Thread.Sleep(3000);
CustomClass message = new CustomClass();
pubnub.Publish (channel, (object)message, common.DisplayReturnMessageDummy);
//cm.deliveryStatus = false;
while (!common.DeliveryStatus);
if (common.Response != null) {
IList<object> fields = common.Response as IList<object>;
if (fields [0] != null)
{
var myObjectArray = (from item in fields select item as object).ToArray ();
Console.WriteLine ("Response:" + myObjectArray[0].ToString ());
CustomClass cc = JsonConvert.DeserializeObject<CustomClass>(myObjectArray[0].ToString());
if(cc.bar.SequenceEqual(message.bar) && cc.foo.Equals(message.foo))
{
Assert.Pass("Complex message test successful");
}
else
{
Assert.Fail("Complex message test not successful");
}
}
else
{
Assert.Fail("No response");
}
}
else
{
Assert.Fail("No response");
}
}
public async void ExecuteTemplate_Sets_Output_And_Calls_ExecuteAsync()
{
//Arrange
var customInstance = new CustomClass();
//Act
var result = await customInstance.ExecuteTemplate();
//Assert
Assert.Equal("SampleText", result);
Assert.True(customInstance.ExecuteAsyncCalled);
}
public void Write()
{
string expectedBody = "<CustomClass xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"><ID>1</ID><Name>Bruno Baïa</Name></CustomClass>";
CustomClass body = new CustomClass("1", "Bruno Baïa");
MockHttpOutputMessage message = new MockHttpOutputMessage();
converter.Write(body, null, message);
Assert.AreEqual(expectedBody, message.GetBodyAsString(Encoding.UTF8), "Invalid result");
Assert.AreEqual(new MediaType("application", "xml"), message.Headers.ContentType, "Invalid content-type");
//Assert.IsTrue(message.Headers.ContentLength > -1, "Invalid content-length");
}
public void Write()
{
string expectedBody = "{\"ID\":\"1\",\"Name\":\"Bruno Baïa\"}";
CustomClass body = new CustomClass("1", "Bruno Baïa");
MockHttpOutputMessage message = new MockHttpOutputMessage();
converter.Write(body, null, message);
Assert.AreEqual(expectedBody, message.GetBodyAsString(Encoding.UTF8), "Invalid result");
Assert.AreEqual(new MediaType("application", "json"), message.Headers.ContentType, "Invalid content-type");
//Assert.IsTrue(message.Headers.ContentLength > -1, "Invalid content-length");
}
public void WriteTo_Does_Not_Fail_For_Null_Object()
{
using (var writer = new StringWriter())
{
//Arrange
var customInstace = new CustomClass();
//Act
customInstace.WriteTo(writer, null);
//Assert
Assert.Equal(string.Empty, writer.ToString());
}
}
protected void TestImplicitCast()
{
bool b = prefsBool;
int i = prefsInt;
float f = prefsFloat;
string s = prefsString;
EnumSample e = prefsEnum;
Color c = prefsColor;
Vector2 v2 = prefsVector2;
Vector3 v3 = prefsVector2;
Vector4 v4 = prefsVector2;
v2 = prefsVector3;
v3 = prefsVector3;
v4 = prefsVector3;
v2 = prefsVector4;
v3 = prefsVector4;
v4 = prefsVector4;
CustomClass customClass = prefsClass;
List <CustomClass> list = prefsList;
}
public override void RightClick()
{
IServiceManager serviceManager = canvas.ServiceManager;
IHigherOrderProgrammingService hope = serviceManager.Get <IHigherOrderProgrammingService>();
// hope.UnloadHopeAssembly();
// hope.LoadHopeAssembly();
if (!hope.RunnerLoaded)
{
hope.LoadHopeAssembly();
hope.InstantiateReceptors();
}
PropertyContainer pc = hope.DescribeSemanticType(Text);
CustomClass cls = new CustomClass();
AddProperties(cls, pc);
PublishSemanticType pst = new PublishSemanticType(Text, pc, cls, hope);
pst.Show();
}
private void toolStripButtonShowProperties_Click(object sender, EventArgs e)
{
CustomClass properties = new CustomClass();
IEnumerable <FieldInfo> fields = typeof(DicomTags).GetFields();
int nonZeroFieldCount = 0;
foreach (FieldInfo fi in fields)
{
String propertyValue = ImageViewerManager.CurrentDicomImageViewControl.GetPropertyValue(fi);
if (propertyValue != null && propertyValue.Length != 0)
{
nonZeroFieldCount++;
properties.Add(new CustomProperty(fi.Name, propertyValue, true, true));
}
}
FDicomProperties dicomPropertiesFormNotModal = new FDicomProperties();
dicomPropertiesFormNotModal.setMyProperties(properties);
dicomPropertiesFormNotModal.Show();
}
public uscPluginPanel()
{
InitializeComponent();
this.m_frmMain = null;
this.m_uscParent = null;
if (this.webDescription.Document == null)
{
this.webDescription.Navigate("about:blank");
this.webDescription.Document.Window.Name = "hi";
}
this.webDescription.Navigating += new WebBrowserNavigatingEventHandler(webDescription_Navigating);
this.m_asmBuilder = Thread.GetDomain().DefineDynamicAssembly(new AssemblyName("PRoConPluginEnumAssembly"), AssemblyBuilderAccess.Run);
this.m_modBuilder = this.m_asmBuilder.DefineDynamicModule("PRoConPluginEnumModule");
this.m_dicGeneratedEnums = new Dictionary <string, Enum>();
this.m_cscPluginVariables = new CustomClass();
this.m_blLocalPlugins = true;
this.lsvLoadedPlugins.CreateGraphics();
}
public void SendReceive_Message_PerClientSerializer()
{
string aClient1Id = null;
IMultiTypedMessagesFactory aSender1Factory = new MultiTypedMessagesFactory()
{
SerializerProvider = x => new XmlStringSerializer()
};
IMultiTypedMessagesFactory aSender2Factory = new MultiTypedMessagesFactory()
{
SerializerProvider = x => new BinarySerializer()
};
IMultiTypedMessagesFactory aReceiverFactory = new MultiTypedMessagesFactory()
{
SerializerProvider = x => (x == aClient1Id) ? (ISerializer) new XmlStringSerializer() : (ISerializer) new BinarySerializer()
};
IMultiTypedMessageSender aSender1 = aSender1Factory.CreateMultiTypedMessageSender();
IMultiTypedMessageSender aSender2 = aSender2Factory.CreateMultiTypedMessageSender();
IMultiTypedMessageReceiver aReceiver = aReceiverFactory.CreateMultiTypedMessageReceiver();
aReceiver.ResponseReceiverConnected += (x, y) => aClient1Id = aClient1Id ?? y.ResponseReceiverId;
int aReceivedMessage1 = 0;
aReceiver.RegisterRequestMessageReceiver <int>((x, y) =>
{
aReceivedMessage1 = y.RequestMessage;
// Send the response
aReceiver.SendResponseMessage <string>(y.ResponseReceiverId, "hello");
});
CustomClass aReceivedMessage2 = null;
aReceiver.RegisterRequestMessageReceiver <CustomClass>((x, y) =>
{
aReceivedMessage2 = y.RequestMessage;
// Send the response
CustomClass aResponse = new CustomClass();
aResponse.Name = "Car";
aResponse.Count = 100;
aReceiver.SendResponseMessage <CustomClass>(y.ResponseReceiverId, aResponse);
});
aReceiver.AttachDuplexInputChannel(DuplexInputChannel);
string aSender1ReceivedResponse1 = "";
aSender1.RegisterResponseMessageReceiver <string>((x, y) =>
{
aSender1ReceivedResponse1 = y.ResponseMessage;
});
AutoResetEvent aSender1MessagesReceivedEvent = new AutoResetEvent(false);
CustomClass aSender1ReceivedResponse2 = null;
aSender1.RegisterResponseMessageReceiver <CustomClass>((x, y) =>
{
aSender1ReceivedResponse2 = y.ResponseMessage;
// Signal that the response message was received -> the loop is closed.
aSender1MessagesReceivedEvent.Set();
});
aSender1.AttachDuplexOutputChannel(MessagingSystemFactory.CreateDuplexOutputChannel(DuplexInputChannel.ChannelId));
string aSender2ReceivedResponse1 = "";
aSender2.RegisterResponseMessageReceiver <string>((x, y) =>
{
aSender2ReceivedResponse1 = y.ResponseMessage;
});
AutoResetEvent aSender2MessagesReceivedEvent = new AutoResetEvent(false);
CustomClass aSender2ReceivedResponse2 = null;
aSender2.RegisterResponseMessageReceiver <CustomClass>((x, y) =>
{
aSender2ReceivedResponse2 = y.ResponseMessage;
// Signal that the response message was received -> the loop is closed.
aSender2MessagesReceivedEvent.Set();
});
aSender2.AttachDuplexOutputChannel(MessagingSystemFactory.CreateDuplexOutputChannel(DuplexInputChannel.ChannelId));
try
{
aSender1.SendRequestMessage <int>(1000);
CustomClass aCustomRequest = new CustomClass();
aCustomRequest.Name = "House";
aCustomRequest.Count = 1000;
aSender1.SendRequestMessage <CustomClass>(aCustomRequest);
aSender2.SendRequestMessage <int>(1000);
aSender2.SendRequestMessage <CustomClass>(aCustomRequest);
// Wait for the signal that the message is received.
aSender1MessagesReceivedEvent.WaitIfNotDebugging(2000);
aSender2MessagesReceivedEvent.WaitIfNotDebugging(2000);
}
finally
{
aSender1.DetachDuplexOutputChannel();
aSender2.DetachDuplexOutputChannel();
aReceiver.DetachDuplexInputChannel();
}
// Check received values
Assert.AreEqual(1000, aReceivedMessage1);
Assert.AreEqual("hello", aSender1ReceivedResponse1);
Assert.AreEqual("hello", aSender2ReceivedResponse1);
Assert.IsNotNull(aReceivedMessage2);
Assert.AreEqual("House", aReceivedMessage2.Name);
Assert.AreEqual(1000, aReceivedMessage2.Count);
Assert.IsNotNull(aSender1ReceivedResponse2);
Assert.AreEqual("Car", aSender1ReceivedResponse2.Name);
Assert.AreEqual(100, aSender1ReceivedResponse2.Count);
Assert.IsNotNull(aSender2ReceivedResponse2);
Assert.AreEqual("Car", aSender2ReceivedResponse2.Name);
Assert.AreEqual(100, aSender2ReceivedResponse2.Count);
}
public void ThenUnencryptObjectPublishShouldReturnSuccessCodeAndInfo()
{
isUnencryptObjectPublished = false;
Pubnub pubnub = new Pubnub(PubnubCommon.PublishKey, PubnubCommon.SubscribeKey, "", "", false);
string channel = "hello_my_channel";
object message = new CustomClass();
messageObjectForUnencryptPublish = JsonConvert.SerializeObject(message);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenAMessageIsPublished";
unitTest.TestCaseName = "ThenUnencryptObjectPublishShouldReturnSuccessCodeAndInfo";
pubnub.PubnubUnitTest = unitTest;
EnqueueCallback(() => pubnub.Publish<string>(channel, message, ReturnSuccessUnencryptObjectPublishCodeCallback, DummyErrorCallback));
EnqueueConditional(() => isUnencryptObjectPubCheck);
EnqueueCallback(() =>
{
if (!isUnencryptObjectPublished)
{
Assert.IsTrue(isUnencryptObjectPublished, "Unencrypt Publish Failed");
}
else
{
EnqueueCallback(() => pubnub.DetailedHistory<string>(channel, -1, unEncryptObjectPublishTimetoken, -1, false, CaptureUnencryptObjectDetailedHistoryCallback, DummyErrorCallback));
EnqueueConditional(() => isUnencryptObjectDHCheck);
EnqueueCallback(() => Assert.IsTrue(isUnencryptObjectDH, "Unable to match the successful unencrypt object Publish"));
}
});
EnqueueTestComplete();
}
public void pickle(object o, Stream outs, Pickler currentpickler)
{
CustomClass c = (CustomClass)o;
currentpickler.save("customclassint=" + c.x);
}
public object CustomClassCreation()
{
return(custom_obj = new CustomClass());
}
public void RemoveProperty(CustomClass obj, string propertyName)
{
var action = new RemovePropertyAction(obj, propertyName);
HandlePushAction(action, false);
}
public void TestMyObjectDecryptionJSONFx()
{
PubnubCrypto pubnubCrypto = new PubnubCrypto("enigma");
//Deserialized
string message = "Zbr7pEF/GFGKj1rOstp0tWzA4nwJXEfj+ezLtAr8qqE=";
//Decrypt
string decrypted = pubnubCrypto.Decrypt(message);
//create an object of the custom class
CustomClass cc = new CustomClass();
//Serialize it
string result = Common.SerializeUsingJSONFx(cc);
Assert.AreEqual(decrypted, result);
}
public void ThenUnencryptObjectPublishShouldReturnSuccessCodeAndInfo()
{
isUnencryptObjectPublished = false;
mrePublish = new ManualResetEvent(false);
mreDetailedHistory = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem((s) =>
{
Pubnub pubnub = new Pubnub(PubnubCommon.PublishKey, PubnubCommon.SubscribeKey, "", "", false);
string channel = "hello_my_channel";
object message = new CustomClass();
messageObjectForUnencryptPublish = JsonConvert.SerializeObject(message);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenAMessageIsPublished";
unitTest.TestCaseName = "ThenUnencryptObjectPublishShouldReturnSuccessCodeAndInfo";
pubnub.PubnubUnitTest = unitTest;
EnqueueCallback(() => pubnub.Publish<string>(channel, message, ReturnSuccessUnencryptObjectPublishCodeCallback, DummyPublishErrorCallback));
mrePublish.WaitOne(310 * 1000);
EnqueueCallback(() =>
{
if (!isUnencryptObjectPublished)
{
Assert.IsTrue(isUnencryptObjectPublished, "Unencrypt Publish Failed");
}
else
{
pubnub.DetailedHistory<string>(channel, -1, unEncryptObjectPublishTimetoken, -1, false, CaptureUnencryptObjectDetailedHistoryCallback, DummyDetailedHistoryErrorCallback);
mreDetailedHistory.WaitOne(310 * 1000);
Assert.IsTrue(isUnencryptObjectDH, "Unable to match the successful unencrypt object Publish");
}
});
EnqueueCallback(() =>
{
pubnub.PubnubUnitTest = null;
pubnub = null;
}
);
EnqueueTestComplete();
});
}
public List <CustomizableFieldValue> CheckCustomizableFields(OCustomizableFieldEntities entity, CustomClass customFields,
CollectionList customizableFieldsCollections, int linkId, char linkType)
{
List <CustomizableFieldValue> fieldValues = new List <CustomizableFieldValue>();
var customizableFieldsServices = ServicesProvider.GetInstance().GetCustomizableFieldsServices();
List <CustomizableField> customizableFields = customizableFieldsServices.
SelectCustomizableFields((int)Enum.Parse(typeof(OCustomizableFieldEntities), entity.ToString()));
if (customizableFields != null)
{
foreach (CustomizableField field in customizableFields)
{
CustomizableFieldValue customizableFieldValue = new CustomizableFieldValue {
Field = field
};
var fieldName = field.Name;
switch (field.Type)
{
case OCustomizableFieldTypes.Boolean:
customizableFieldValue.Value = ((bool)customFields.GetPropertyValueByName(fieldName)).ToString(CultureInfo.InvariantCulture);
break;
case OCustomizableFieldTypes.Number:
customizableFieldValue.Value = ((string)customFields.GetPropertyValueByName(fieldName));
break;
case OCustomizableFieldTypes.String:
customizableFieldValue.Value = (string)customFields.GetPropertyValueByName(fieldName);
break;
case OCustomizableFieldTypes.Date:
DateTime dateValue = (DateTime)customFields.GetPropertyValueByName(fieldName);
customizableFieldValue.Value = Converter.CustomFieldDateToString(dateValue);
break;
case OCustomizableFieldTypes.Client:
customizableFieldValue.Value = customFields.GetPropertyValueByName(fieldName).ToString();
break;
case OCustomizableFieldTypes.Collection:
{
int index = customizableFieldsCollections.GetItemIndexByName(fieldName, (string)customFields.GetPropertyValueByName(fieldName));
if (index != -1)
{
customizableFieldValue.Value = index.ToString(CultureInfo.InvariantCulture);
}
}
break;
}
var fieldType = field.Type;
var fieldValue = customizableFieldValue.Value;
if (customizableFieldValue.Field.IsMandatory)
{
if (
(fieldType == OCustomizableFieldTypes.Number && fieldValue == string.Empty) ||
(fieldType == OCustomizableFieldTypes.String && fieldValue == string.Empty) ||
(fieldType == OCustomizableFieldTypes.Date && Converter.CustomFieldValueToDate(fieldValue) == DateTime.MinValue) ||
(fieldType == OCustomizableFieldTypes.Collection && fieldValue == null) ||
(fieldType == OCustomizableFieldTypes.Client && fieldValue == string.Empty)
)
{
throw new OpenCbsContractSaveException(OpenCbsContractSaveExceptionEnum.FieldIsMandatory);
}
}
if (fieldType == OCustomizableFieldTypes.Number)
{
if (fieldValue != string.Empty)
{
decimal result;
if (!Converter.CustomFieldDecimalParse(out result, fieldValue))
{
throw new OpenCbsContractSaveException(
OpenCbsContractSaveExceptionEnum.NumberFieldIsNotANumber);
}
}
}
if (fieldType == OCustomizableFieldTypes.String)
{
if (fieldValue.Length > 300)
{
throw new OpenCbsCustomFieldNameException(OCustomFieldExceptionEnum.FieldLimited);
}
}
if (field.IsUnique)
{
if (
fieldType == OCustomizableFieldTypes.Number ||
fieldType == OCustomizableFieldTypes.String ||
fieldType == OCustomizableFieldTypes.Date ||
fieldType == OCustomizableFieldTypes.Client
)
{
if (customizableFieldsServices.FieldValueExists(linkId, linkType, customizableFieldValue.Field.Id, fieldValue))
{
throw new OpenCbsContractSaveException(OpenCbsContractSaveExceptionEnum.FieldIsNotUnique);
}
}
}
fieldValues.Add(customizableFieldValue);
}
}
return(fieldValues);
}
protected bool Equals(CustomClass other)
{
return(SomeProperty == other.SomeProperty && AnotherProperty == other.AnotherProperty);
}
public void Add(CustomClass a)
{
_list.Add(a);
}
public AddPropertyAction(CustomClass obj, string propertyName)
{
this.obj = obj;
this.propertyName = propertyName;
}
public void TestMyObjectDecryption()
{
Debug.Log("Running TestMyObjectDecryption()");
PubnubCrypto pc = new PubnubCrypto("enigma");
//Deserialized
string message = "Zbr7pEF/GFGKj1rOstp0tWzA4nwJXEfj+ezLtAr8qqE=";
//Decrypt
string decryptedMessage = pc.Decrypt(message);
//create an object of the custom class
CustomClass cc = new CustomClass();
//Serialize it
string result = new JsonFXDotNet().SerializeToJsonString(cc); //JsonConvert.SerializeObject(cc);
UUnitAssert.Equals(result, decryptedMessage);
}
internal static bool Pulse()
{
try
{
// Attach onlevelup for spell book:
EventsLua.AttachEventLua(LuaEventsId.PLAYER_LEVEL_UP, m => OnLevelUp());
EventsLua.AttachEventLua(LuaEventsId.PLAYER_ENTERING_WORLD, m => ScreenReloaded());
// Update spell list
SpellManager.UpdateSpellBook();
// Load CC:
CustomClass.LoadCustomClass();
// FSM
Fsm.States.Clear();
Fsm.AddState(new Relogger {
Priority = 200
});
Fsm.AddState(new Pause {
Priority = 33
});
Fsm.AddState(new Resurrect {
Priority = 32
});
Fsm.AddState(new MyMacro {
Priority = 31
});
Fsm.AddState(new IsAttacked {
Priority = 30
});
Fsm.AddState(new Regeneration {
Priority = 29
});
Fsm.AddState(new Looting {
Priority = 28
});
Fsm.AddState(new FlightMasterTakeTaxiState {
Priority = 27
});
Fsm.AddState(new Farming {
Priority = 26
});
Fsm.AddState(new ToTown {
Priority = 25
});
Fsm.AddState(new SellItemsState {
Priority = 24
});
Fsm.AddState(new SetCurrentStepState {
Priority = 21
});
Fsm.AddState(new SplitItemState {
Priority = 19
});
Fsm.AddState(new DisenchantState {
Priority = 18
});
Fsm.AddState(new FilterLootState {
Priority = 17
});
Fsm.AddState(new TravelState {
Priority = 16
});
Fsm.AddState(new LearnProfessionState {
Priority = 15
});
Fsm.AddState(new BuyAndLearnRecipeState {
Priority = 14
});
Fsm.AddState(new LearnRecipeFromTrainerState {
Priority = 13
});
Fsm.AddState(new BuyMaterialsState {
Priority = 12
});
Fsm.AddState(new CraftOneState {
Priority = 11
});
Fsm.AddState(new EnchantState {
Priority = 10
});
Fsm.AddState(new CraftState {
Priority = 9
});
Fsm.AddState(new LoadProfileState {
Priority = 8
});
Fsm.AddState(Grinding);
Fsm.AddState(MovementLoop);
Fsm.AddState(new Idle {
Priority = 0
});
Fsm.States.Sort();
Fsm.StartEngine(10, "_Profession"); // Fsm.StartEngine(25);
wManager.wManagerSetting.AddBlackListZone(new Vector3(1731.702, -4423.403, 36.86293, "None"), 5.00f, true);
wManager.wManagerSetting.AddBlackListZone(new Vector3(1669.99, -4359.609, 29.23425, "None"), 5.00f, true);
StopBotIf.LaunchNewThread();
return(true);
}
catch (Exception e)
{
try
{
Dispose();
}
catch
{
}
Logging.WriteError("Bot > Bot > Pulse(): " + e);
return(false);
}
}
private static void OnLevelUp()
{
Logging.Write("Level UP! Reload Fight Class.");
SpellManager.UpdateSpellBook();
CustomClass.ResetCustomClass();
}
public void TestMyObjectDecryption()
{
PubnubCrypto pc = new PubnubCrypto("enigma");
//Deserialized
string message = "Zbr7pEF/GFGKj1rOstp0tWzA4nwJXEfj+ezLtAr8qqE=";
//Decrypt
string decryptedMessage = pc.Decrypt(message);
//create an object of the custom class
CustomClass cc = new CustomClass();
//Serialize it
string result = JsonConvert.SerializeObject(cc);
int same = string.Compare (result, decryptedMessage, StringComparison.OrdinalIgnoreCase);
Assert.IsTrue(same == 0);
}
public void pickle(object o, Stream outs, Pickler currentpickler)
{
CustomClass c = (CustomClass)o;
currentpickler.save("customclassint=" + c.x); // write a string representation
}
public void SaveValues(OCustomizableFieldEntities entity, CustomClass customFields, CollectionList customizableFieldsCollections, int linkId, char linkType)
{
List <CustomizableFieldValue> fieldValues = CheckCustomizableFields(entity, customFields, customizableFieldsCollections, linkId, linkType);
_customizableFieldsManager.SaveCustomizableFieldValues(fieldValues, linkId, linkType);
}
void SubscribePublishAndParseComplexObject (Pubnub pubnub, Common common, string channel)
{
CustomClass message = new CustomClass ();
Random r = new Random ();
channel = "hello_world_sub" + r.Next (1000);
pubnub.Subscribe<object> (channel, common.DisplayReturnMessage, common.DisplayReturnMessageDummy, common.DisplayReturnMessageDummy);
Thread.Sleep (5000);
pubnub.Publish (channel, (object)message, common.DisplayReturnMessageDummy, common.DisplayReturnMessageDummy);
common.WaitForResponse ();
if (common.Response != null) {
List<object> lst = common.Response as List<object>;
Console.WriteLine (lst [0].ToString ());
Console.WriteLine (lst [1].ToString ());
if (lst.Count == 3)
Console.WriteLine (lst [2].ToString ());
if (lst.Count == 4)
Console.WriteLine (lst [3].ToString ());
Console.WriteLine ();
if (lst [0] != null) {
CustomClass cc = new CustomClass ();
var dict = lst [0] as IDictionary;
if ((dict != null) && (dict.Count > 1)) {
cc.foo = (string)dict ["foo"];
cc.bar = (int[])dict ["bar"];
} else {
cc = lst[0] as CustomClass;
}
if (cc.bar.SequenceEqual (message.bar) && cc.foo.Equals (message.foo)) {
Assert.Pass ("Complex message test successful");
} else {
Assert.Fail ("Complex message test not successful");
}
} else {
Assert.Fail ("No response1");
}
} else {
Assert.Fail ("No response");
}
common.DeliveryStatus = false;
common.Response = null;
pubnub.Unsubscribe<string> (channel, common.DisplayReturnMessageDummy, common.DisplayReturnMessageDummy, common.DisplayReturnMessage, common.DisplayReturnMessageDummy);
common.WaitForResponse (20);
pubnub.EndPendingRequests ();
}
public static void Main(string[] args)
{
List <string> slist;
slist = new List <string>();
Console.WriteLine(slist.Count);
Console.WriteLine("String list with 10 elements");
slist = new List <string>(10);
Console.WriteLine(slist.Count);
for (int i = 0; i < slist.Count; i++)
{
PrintBool(slist[i] == null);
}
Console.WriteLine("Intlist with 10 elements");
List <int> intList = new List <int>(10);
Console.WriteLine(intList.Count);
for (int i = 0; i < intList.Count; i++)
{
PrintBool(intList[i] == 0);
}
Console.WriteLine("String list with initializer ");
slist = new List <string> {
"zero", "one", "two", "three"
};
for (int i = 0; i < slist.Count; i++)
{
Console.WriteLine(slist[i]);
}
Console.WriteLine("String list with array constructor ");
string[] sArray = { "apple", "orange", "plum" };
slist = new List <string>(sArray);
for (int i = 0; i < slist.Count; i++)
{
Console.WriteLine(slist[i]);
}
Console.WriteLine("ListWith custom Class Initializer");
List <CustomClass> ccList = new List <CustomClass>()
{
new CustomClass()
{
Field1 = "1.first", Field2 = "1.Second"
}, new CustomClass()
{
Field1 = "2.first", Field2 = "2.Second"
}
};
for (int i = 0; i < ccList.Count; i++)
{
Console.WriteLine(ccList[i].ToString());
}
var cc = new CustomClass()
{
Field1 = "one", Field2 = "two"
};
ccList = new List <CustomClass>()
{
cc
};
PrintBool(ccList[0] == cc);
}
public override void Initialize()
{
Images.Cache();
_target = metadata.value as CustomClass;
generator = CustomClassGenerator.GetDecorator(_target);
}
public static void TestCC4()
{
Console.WriteLine("Test CC4");
CustomClass cc = new CustomClass();
cc[0] = "bart";
cc[1] = "grant";
cc[2] = "chad";
Console.WriteLine("cc[{0}] = {1}", 0, cc[0]);
Console.WriteLine("cc[{0}] = {1}", 1, cc[1]);
Console.WriteLine("cc[{0}] = {1}", 2, cc[2]);
}
public RemovePropertyAction(CustomClass obj, string propertyName)
{
this.obj = obj;
this.propertyName = propertyName;
this.value = obj.GetValue(propertyName);
}
public void ThenItShouldReturnSuccessCodeAndInfoForComplexMessage ()
{
Pubnub pubnub = new Pubnub (
Common.PublishKey,
Common.SubscribeKey,
"",
"",
false
);
string channel = "hello_world";
object message = new CustomClass ();
Common common = new Common ();
pubnub.PubnubUnitTest = common.CreateUnitTestInstance ("WhenAMessageIsPublished", "ThenItShouldReturnSuccessCodeAndInfoForComplexMessage");
common.DeliveryStatus = false;
common.Response = null;
pubnub.Publish (channel, message, common.DisplayReturnMessage, common.DisplayErrorMessage);
//wait till the response is received from the server
common.WaitForResponse ();
if (common.Response != null) {
IList<object> fields = common.Response as IList<object>;
string sent = fields [1].ToString ();
string one = fields [0].ToString ();
Assert.True (("Sent").Equals (sent));
Assert.True (("1").Equals (one));
} else {
Assert.Fail ("Null response");
}
}
public MyDerivedClass(SomeEnum enumValue, User user, CustomClass customStuff)
: base(enumValue, user)
{
}
private static void CustomSerialization()
{
CustomClass cc = new CustomClass();
SavaData("customSer.xml", cc, SerializeFormatter.Soap);
}
// Match is Predicate<CustomClass>
public bool Match(CustomClass cc)
{
return(cc.Path == _u);
}
public void setMyProperties(CustomClass properties)
{
propertyGrid1.SelectedObject = properties;
propertyGrid1.Refresh();
}
private void CommonComplexMessageSubscribeShouldReturnReceivedMessageBasedOnParams(string secretKey, string cipherKey, bool ssl)
{
receivedMessage = false;
pubnub = new Pubnub(PubnubCommon.PublishKey, PubnubCommon.SubscribeKey, secretKey, cipherKey, ssl);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenSubscribedToAChannel";
unitTest.TestCaseName = (string.IsNullOrEmpty(cipherKey)) ? "ThenSubscribeShouldReturnReceivedComplexMessage" : "ThenSubscribeShouldReturnReceivedCipherComplexMessage";
pubnub.PubnubUnitTest = unitTest;
string channel = "hello_my_channel";
mreSubscribe = new ManualResetEvent(false);
mreSubscribeConnect = new ManualResetEvent(false);
pubnub.Subscribe<string>(channel, ReceivedMessageCallbackWhenSubscribed, SubscribeDummyMethodForConnectCallback, DummyErrorCallback);
mreSubscribeConnect.WaitOne(manualResetEventsWaitTimeout);
mrePublish = new ManualResetEvent(false);
publishedMessage = new CustomClass();
pubnub.Publish<string>(channel, publishedMessage, dummyPublishCallback, DummyErrorCallback);
manualResetEventsWaitTimeout = (unitTest.EnableStubTest) ? 1000 : 310 * 1000;
mrePublish.WaitOne(manualResetEventsWaitTimeout);
if (isPublished)
{
mreSubscribe.WaitOne(manualResetEventsWaitTimeout);
mreUnsubscribe = new ManualResetEvent(false);
pubnub.Unsubscribe<string>(channel, dummyUnsubscribeCallback, SubscribeDummyMethodForConnectCallback, UnsubscribeDummyMethodForDisconnectCallback, DummyErrorCallback);
mreUnsubscribe.WaitOne(manualResetEventsWaitTimeout);
}
pubnub.EndPendingRequests();
pubnub.PubnubUnitTest = null;
pubnub = null;
}
public void ThenItShouldReturnReceivedMessageCipherForComplexMessage ()
{
Pubnub pubnub = new Pubnub (
"demo",
"demo",
"",
"enigma",
false);
string channel = "hello_world";
Common common = new Common();
common.DeliveryStatus = false;
common.Response = null;
pubnub.PubnubUnitTest = common.CreateUnitTestInstance("WhenSubscribedToAChannel", "ThenItShouldReturnReceivedMessageCipherForComplexMessage");
CustomClass message = new CustomClass();
pubnub.Subscribe (channel, common.DisplayReturnMessage, common.DisplayReturnMessageDummy, common.DisplayReturnMessageDummy);
Thread.Sleep(3000);
pubnub.Publish (channel, (object)message, common.DisplayReturnMessageDummy, common.DisplayReturnMessageDummy);
common.WaitForResponse();
if (common.Response != null) {
IList<object> fields = common.Response as IList<object>;
if (fields [0] != null)
{
var myObjectArray = (from item in fields select item as object).ToArray ();
CustomClass cc = new CustomClass();
//If the custom class is serialized with jsonfx the response is received as a dictionary and
//on deserialization with Newtonsoft.Json we get an error.
//As a work around we parse the dictionary object.
var dict = myObjectArray [0] as IDictionary;
if ((dict != null) && (dict.Count > 1))
{
cc.foo = (string)dict["foo"];
cc.bar = (int[])dict["bar"];
}
else
{
cc = Common.Deserialize<CustomClass>(myObjectArray[0].ToString());
/* #if (USE_JSONFX)
var reader = new JsonFx.Json.JsonReader();
cc = reader.Read<CustomClass>(myObjectArray[0].ToString());
#else
cc = JsonConvert.DeserializeObject<CustomClass>(myObjectArray[0].ToString());
#endif*/
}
if(cc.bar.SequenceEqual(message.bar) && cc.foo.Equals(message.foo))
{
Assert.Pass("Complex message test successful");
}
else
{
Assert.Fail("Complex message test not successful");
}
}
else
{
Assert.Fail("No response");
}
}
else
{
Assert.Fail("No response");
}
}
public void SendReceive_Message()
{
// The test can be performed from more threads therefore we must synchronize.
AutoResetEvent aMessageReceivedEvent = new AutoResetEvent(false);
int aReceivedMessage1 = 0;
Responser.RegisterRequestMessageReceiver <int>((x, y) =>
{
aReceivedMessage1 = y.RequestMessage;
// Send the response
Responser.SendResponseMessage <string>(y.ResponseReceiverId, "hello");
});
CustomClass aReceivedMessage2 = null;
Responser.RegisterRequestMessageReceiver <CustomClass>((x, y) =>
{
aReceivedMessage2 = y.RequestMessage;
// Send the response
CustomClass aResponse = new CustomClass();
aResponse.Name = "Car";
aResponse.Count = 100;
Responser.SendResponseMessage <CustomClass>(y.ResponseReceiverId, aResponse);
});
Responser.AttachDuplexInputChannel(DuplexInputChannel);
string aReceivedResponse1 = "";
Requester.RegisterResponseMessageReceiver <string>((x, y) =>
{
aReceivedResponse1 = y.ResponseMessage;
});
CustomClass aReceivedResponse2 = null;
Requester.RegisterResponseMessageReceiver <CustomClass>((x, y) =>
{
aReceivedResponse2 = y.ResponseMessage;
// Signal that the response message was received -> the loop is closed.
aMessageReceivedEvent.Set();
});
Requester.AttachDuplexOutputChannel(DuplexOutputChannel);
try
{
Requester.SendRequestMessage <int>(1000);
CustomClass aCustomRequest = new CustomClass();
aCustomRequest.Name = "House";
aCustomRequest.Count = 1000;
Requester.SendRequestMessage <CustomClass>(aCustomRequest);
// Wait for the signal that the message is received.
aMessageReceivedEvent.WaitOne();
//Assert.IsTrue(aMessageReceivedEvent.WaitOne(2000));
}
finally
{
Requester.DetachDuplexOutputChannel();
Responser.DetachDuplexInputChannel();
Responser.DetachDuplexInputChannel();
}
// Check received values
Assert.AreEqual(1000, aReceivedMessage1);
Assert.AreEqual("hello", aReceivedResponse1);
Assert.IsNotNull(aReceivedMessage2);
Assert.AreEqual("House", aReceivedMessage2.Name);
Assert.AreEqual(1000, aReceivedMessage2.Count);
Assert.IsNotNull(aReceivedResponse2);
Assert.AreEqual("Car", aReceivedResponse2.Name);
Assert.AreEqual(100, aReceivedResponse2.Count);
}
public void testCustomPickler()
{
Pickler.registerCustomPickler(typeof(CustomClass), new CustomClassPickler());
CustomClass c=new CustomClass();
Pickler p=new Pickler(false);
byte[] ser = p.dumps(c);
Unpickler u = new Unpickler();
string x = (string) u.loads(ser);
Assert.AreEqual("customclassint=42", x);
}
public void TestMyObjectDecryption()
{
PubnubCrypto pc = new PubnubCrypto("enigma");
//Deserialized
string message = "Zbr7pEF/GFGKj1rOstp0tWzA4nwJXEfj+ezLtAr8qqE=";
//Decrypt
string decryptedMessage = pc.Decrypt(message);
//create an object of the custom class
CustomClass cc = new CustomClass();
//Serialize it
string result = JsonConvert.SerializeObject(cc);
Assert.AreEqual(result, decryptedMessage);
}
public string LogStartup(CustomClass obj)
{
return(obj.Name + "=>" + obj.Id);
}
public void ThenUnencryptObjectPublishShouldReturnSuccessCodeAndInfo()
{
isUnencryptObjectPublished = false;
Pubnub pubnub = new Pubnub(PubnubCommon.PublishKey, PubnubCommon.SubscribeKey, "", "", false);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenAMessageIsPublished";
unitTest.TestCaseName = "ThenUnencryptObjectPublishShouldReturnSuccessCodeAndInfo";
pubnub.PubnubUnitTest = unitTest;
string channel = "hello_my_channel";
object message = new CustomClass();
messageObjectForUnencryptPublish = JsonConvert.SerializeObject(message);
pubnub.Publish<string>(channel, message, ReturnSuccessUnencryptObjectPublishCodeCallback, DummyErrorCallback);
manualResetEventsWaitTimeout = (unitTest.EnableStubTest) ? 1000 : 310 * 1000;
mreUnencryptObjectPublish.WaitOne(manualResetEventsWaitTimeout);
if (!isUnencryptObjectPublished)
{
pubnub.PubnubUnitTest = null;
pubnub = null;
Assert.IsTrue(isUnencryptObjectPublished, "Unencrypt Publish Failed");
}
else
{
Task.Delay(1000);
pubnub.DetailedHistory<string>(channel, -1, unEncryptObjectPublishTimetoken, -1, false, CaptureUnencryptObjectDetailedHistoryCallback, DummyErrorCallback);
mreUnencryptObjectDetailedHistory.WaitOne(manualResetEventsWaitTimeout);
pubnub.PubnubUnitTest = null;
pubnub = null;
Assert.IsTrue(isUnencryptObjectDetailedHistory, "Unable to match the successful unencrypt object Publish");
}
}
//will fail with minijson
//[Test]
public void TestMyObjectDecryptionMiniJson ()
{
PubnubCrypto pubnubCrypto = new PubnubCrypto ("enigma");
//Deserialized
string message = "Zbr7pEF/GFGKj1rOstp0tWzA4nwJXEfj+ezLtAr8qqE=";
//Decrypt
string decrypted = pubnubCrypto.Decrypt (message);
//create an object of the custom class
CustomClass cc = new CustomClass ();
//Serialize it
string result = Common.SerializeMiniJson (cc);
UnityEngine.Debug.Log ("decrypted:" + decrypted);
UnityEngine.Debug.Log ("result:" + result);
Assert.True ((decrypted).Equals (result));
}
void SubscribePublishAndParseComplex (Pubnub pubnub, Common common, string channel)
{
Random r = new Random ();
channel = "hello_world_sub" + r.Next (1000);
CustomClass message = new CustomClass ();
pubnub.Subscribe<string> (channel, common.DisplayReturnMessage, common.DisplayReturnMessageDummy, common.DisplayReturnMessageDummy);
Thread.Sleep (5000);
pubnub.NonSubscribeTimeout = 30;
pubnub.Publish (channel, (object)message, common.DisplayReturnMessageDummy, common.DisplayReturnMessageDummy);
pubnub.NonSubscribeTimeout = 15;
common.WaitForResponse ();
if (common.Response != null) {
object[] fields = Common.Deserialize<object[]> (common.Response.ToString ());
if (fields [0] != null) {
var myObjectArray = (from item in fields
select item as object).ToArray ();
CustomClass cc = new CustomClass ();
//If the custom class is serialized with jsonfx the response is received as a dictionary and
//on deserialization with Newtonsoft.Json we get an error.
//As a work around we parse the dictionary object.
var dict = myObjectArray [0] as IDictionary;
if ((dict != null) && (dict.Count > 1)) {
cc.foo = (string)dict ["foo"];
cc.bar = (int[])dict ["bar"];
} else {
cc = Common.Deserialize<CustomClass> (myObjectArray [0].ToString ());
/* #if (USE_JSONFX)
var reader = new JsonFx.Json.JsonReader();
cc = reader.Read<CustomClass>(myObjectArray[0].ToString());
#else
cc = JsonConvert.DeserializeObject<CustomClass>(myObjectArray[0].ToString());
#endif*/
}
if (cc.bar.SequenceEqual (message.bar) && cc.foo.Equals (message.foo)) {
Assert.Pass ("Complex message test successful");
} else {
Assert.Fail ("Complex message test not successful");
}
} else {
Assert.Fail ("No response");
}
} else {
Assert.Fail ("No response");
}
common.DeliveryStatus = false;
common.Response = null;
pubnub.Unsubscribe<string> (channel, common.DisplayReturnMessageDummy, common.DisplayReturnMessageDummy, common.DisplayReturnMessage, common.DisplayReturnMessageDummy);
common.WaitForResponse (20);
pubnub.EndPendingRequests ();
}
public void TestMyObjectEncryption()
{
PubnubCrypto pc = new PubnubCrypto("enigma");
//create an object of the custom class
CustomClass cc = new CustomClass();
//serialize it
JavaScriptSerializer js = new JavaScriptSerializer();
string res = js.Serialize(cc);
//encrypt it
string enc = pc.encrypt(res);
Assert.AreEqual("Zbr7pEF/GFGKj1rOstp0tWzA4nwJXEfj+ezLtAr8qqE=", enc);
}
public void TestMyObjectEncryptionJSONFx()
{
PubnubCrypto pubnubCrypto = new PubnubCrypto("enigma");
//create an object of the custom class
CustomClass cc = new CustomClass();
//serialize it
string result = Common.SerializeUsingJSONFx(cc);
//encrypt it
string encrypted = pubnubCrypto.Encrypt(result);
Assert.AreEqual("Zbr7pEF/GFGKj1rOstp0tWzA4nwJXEfj+ezLtAr8qqE=", encrypted);
}
public void ThenUnencryptObjectPublishShouldReturnSuccessCodeAndInfo()
{
ThreadPool.QueueUserWorkItem((s) =>
{
isUnencryptObjectPublished = false;
Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
string channel = "my/channel";
object message = new CustomClass();
messageObjectForUnencryptPublish = JsonConvert.SerializeObject(message);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenAMessageIsPublished";
unitTest.TestCaseName = "ThenUnencryptObjectPublishShouldReturnSuccessCodeAndInfo";
pubnub.PubnubUnitTest = unitTest;
pubnub.Publish<string>(channel, message, ReturnSuccessUnencryptObjectPublishCodeCallback);
mreUnencryptObjectPublish.WaitOne(310 * 1000);
if (!isUnencryptObjectPublished)
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
Assert.IsTrue(isUnencryptObjectPublished, "Unencrypt Publish Failed");
TestComplete();
});
}
else
{
pubnub.DetailedHistory<string>(channel, -1, unEncryptObjectPublishTimetoken, -1, false, CaptureUnencryptObjectDetailedHistoryCallback);
mreUnencryptObjectDetailedHistory.WaitOne(310 * 1000);
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
Assert.IsTrue(isUnencryptObjectDetailedHistory, "Unable to match the successful unencrypt object Publish");
TestComplete();
});
}
});
}
public void ThenUnencryptObjectPublishShouldReturnSuccessCodeAndInfo()
{
Debug.Log("Running ThenUnencryptObjectPublishShouldReturnSuccessCodeAndInfo()");
isUnencryptObjectPublished = false;
Pubnub pubnub = new Pubnub("demo", "demo", "", "", false);
PubnubUnitTest unitTest = new PubnubUnitTest();
unitTest.TestClassName = "WhenAMessageIsPublished";
unitTest.TestCaseName = "ThenUnencryptObjectPublishShouldReturnSuccessCodeAndInfo";
pubnub.PubnubUnitTest = unitTest;
string channel = "my/channel";
object message = new CustomClass();
messageObjectForUnencryptPublish = JsonConvert.SerializeObject(message);
pubnub.Publish<string>(channel, message, ReturnSuccessUnencryptObjectPublishCodeCallback);
mreUnencryptObjectPublish.WaitOne(310 * 1000);
if (!isUnencryptObjectPublished)
{
UUnitAssert.True(isUnencryptObjectPublished, "Unencrypt Publish Failed");
}
else
{
pubnub.DetailedHistory<string>(channel, -1, unEncryptObjectPublishTimetoken, -1, false, CaptureUnencryptObjectDetailedHistoryCallback);
mreUnencryptObjectDetailedHistory.WaitOne(310 * 1000);
UUnitAssert.True(isUnencryptObjectDetailedHistory, "Unable to match the successful unencrypt object Publish");
}
}
public static IEnumerable <object[]> GetTestData()
{
// Should convert variable values to string
var customObj = new CustomClass("some_data");
yield return(new object[]
{
null,
new Dictionary <string, object> {
{ "name", "World" }, { "var1", customObj }, { "var2", -0.5 }, { "var3", string.Empty }
},
"Hello, $.name! I like $.var1, $.var2 and $.var3, $.name.",
$"Hello, World! I like some_data, -0.5 and , World.",
});
// Should ignore extra variables
yield return(new object[]
{
null,
new Dictionary <string, object> {
{ "var1", 1 }, { "var2", 2 }
},
"Only $.var1",
"Only 1",
});
// Should allow empty variables
yield return(new object[]
{
null,
new Dictionary <string, object>(),
"$.something",
"$.something",
});
// Should ignore non-existent variables in the template
yield return(new object[]
{
null,
new Dictionary <string, object> {
{ "var1", 1 }
},
"$.var1 $.var",
"1 $.var",
});
// ..even with the special name
yield return(new object[]
{
null,
new Dictionary <string, object> {
{ "var1", 1 }
},
$"$.{Constants.DeviceIdValueName} $.var1 $.var",
$"$.{Constants.DeviceIdValueName} 1 $.var",
});
// Should substitute longer names first
yield return(new object[]
{
null,
new Dictionary <string, object> {
{ "var1", 1 }, { "var", 2 }, { "var11", 3 }
},
"$.var1$.var11, $.var $.var$.var1$.var11!",
"13, 2 213!",
});
// Should substitute DeviceID if it's in the previous values
yield return(new object[]
{
new Dictionary <string, object> {
{ Constants.DeviceIdValueName, "dummy" }
},
new Dictionary <string, object> {
{ "var1", 1 }
},
$"$.{Constants.DeviceIdValueName} $.var1!",
"dummy 1!",
});
}
//will fail with minijson
//[Test]
public void TestMyObjectEncryptionMiniJson ()
{
PubnubCrypto pubnubCrypto = new PubnubCrypto ("enigma");
//create an object of the custom class
CustomClass cc = new CustomClass ();
//serialize it
string result = Common.SerializeMiniJson (cc);
//encrypt it
string encrypted = pubnubCrypto.Encrypt (result);
UnityEngine.Debug.Log ("encrypted:" + encrypted);
UnityEngine.Debug.Log ("result:" + result);
Assert.True (("Zbr7pEF/GFGKj1rOstp0tWzA4nwJXEfj+ezLtAr8qqE=").Equals (encrypted));
}
public void PropertyChange(CustomClass currentObject, object oldValue, string propertyName)
{
var action = new PropertyChangeAction(currentObject, oldValue, propertyName);
HandlePushAction(action, false);
}
public ObjectLog ConvertToObjectLog(object convertedObject)
{
CustomClass customClass = convertedObject as CustomClass;
return(new ObjectLog(customClass.Name, $"{customClass.ImportantValue}"));
}
public CustomClass(string myString, CustomClass customClass)
{
StringProperty = myString;
CustomClassProperty = customClass;
}
public void TestMyObjectDecryption()
{
PubnubCrypto pc = new PubnubCrypto("enigma");
//Deserialized
string strMessage = "Zbr7pEF/GFGKj1rOstp0tWzA4nwJXEfj+ezLtAr8qqE=";
//Decrypt
string dec = pc.decrypt(strMessage);
//create an object of the custom class
CustomClass cc = new CustomClass();
JavaScriptSerializer js = new JavaScriptSerializer();
//Serialize it
string res = js.Serialize(cc);
Assert.AreEqual(res, dec);
}
public void Property_can_be_set_to_value_of_custom_type()
{
var expected = new CustomClass();
_viewModel.CustomProperty = expected;
Assert.AreSame(expected, _viewModel.CustomProperty);
}
/// <summary>
/// Set a CC of the list as current CC
/// </summary>
public void SetCurrent(int parIndex)
{
Current = Enumerator.ElementAt(parIndex);
}
public void Interface_property_can_be_set_to_value_of_implementing_type()
{
var expected = new CustomClass();
_viewModel.CustomInterfaceProperty = expected;
Assert.AreSame(expected, _viewModel.CustomInterfaceProperty);
}
public void ThenItShouldReturnSuccessCodeAndInfoForComplexMessage()
{
Pubnub pubnub = new Pubnub(
"demo",
"demo",
"",
"",
false
);
string channel = "hello_world";
object message = new CustomClass();
Common common = new Common();
pubnub.PubnubUnitTest = common.CreateUnitTestInstance("WhenAMessageIsPublished", "ThenItShouldReturnSuccessCodeAndInfoForComplexMessage");
common.DeliveryStatus = false;
common.Response = null;
pubnub.Publish(channel, message, common.DisplayReturnMessage);
//wait till the response is received from the server
while (!common.DeliveryStatus) ;
IList<object> fields = common.Response as IList<object>;
string sent = fields[1].ToString();
string one = fields[0].ToString();
Assert.AreEqual("Sent", sent);
Assert.AreEqual("1", one);
}
public When_created_based_on_custom_type()
{
source = new CustomClass { Prop1 = "Value1" };
dynamicObject = new DynamicObject(source);
}
