public void SerializerTest()
{
var stock1 = new ValuatedStock();
var stock2 = new ValuatedStock();
ValuatedStock[] stocks = { stock1, stock2 };
string date1 = "1990-02-20";
MarketDay day1 = new MarketDay(date1, stocks);
var recentHistory = new MarketSegment
{
day1
};
var stockStreamResponse = new StockHistoryResponseMessage
{
RecentHistory = recentHistory
};
var serializedMessage = stockStreamResponse.Encode();
var deserializedMessage = MessageFactory.GetMessage(serializedMessage, false) as StockHistoryResponseMessage;
Assert.AreEqual(stockStreamResponse.RecentHistory[0].TradedCompanies.Count, deserializedMessage.RecentHistory[0].TradedCompanies.Count);
Assert.AreEqual(stockStreamResponse.RecentHistory[0].TradedCompanies[0].Close, deserializedMessage.RecentHistory[0].TradedCompanies[0].Close);
Assert.AreEqual(stockStreamResponse.RecentHistory[0].Date, deserializedMessage.RecentHistory[0].Date);
}
public static bool Prefix(Sign __instance, Farmer who, bool justCheckingForActivity, ref bool __result)
{
if (justCheckingForActivity)
{
return(true);
}
var owner = MapUtility.Owner(__instance);
MarketDay.Log(
$"Prefix_Sign_checkForAction checking {__instance} {__instance.DisplayName} owner {owner} at {__instance.TileLocation}",
LogLevel.Debug, true);
if (owner is null || owner == $"Farmer:{who.Name}")
{
return(true);
}
MarketDay.Log(
$"Prefix_Sign_checkForAction preventing action on object at {__instance.TileLocation} owned by {owner}",
LogLevel.Debug, true);
who.currentLocation.playSound("clank");
__instance.shakeTimer = 500;
__result = false;
return(false);
}
public static ISalable GetDGAObjectByName(string name, string itemType = "Object")
{
if (APIs.dgaApi.Value is not {
} dgaApi)
{
MarketDay.Log($"{name}/{itemType}: could not get DGA API", LogLevel.Trace);
return(null);
}
var obj = dgaApi.SpawnDGAItem(name);
switch (obj)
{
case null:
MarketDay.Log($"{name}/{itemType}: not a DGA object", LogLevel.Trace);
return(null);
case ISalable item:
return(item);
default:
MarketDay.Log($"{name}/{itemType}: not a saleable object", LogLevel.Trace);
return(null);
}
}
internal void CheckItems()
{
MarketDay.Log("Checking progression data", LogLevel.Debug);
if (Levels.Count == 0)
{
MarketDay.Log($" No levels loaded", LogLevel.Error);
}
foreach (var level in Levels)
{
foreach (var prizeLevel in level.Prizes)
{
var name = prizeLevel.Object;
var item = ItemsUtil.GetIndexByName(name);
if (item == -1)
{
MarketDay.Log($" Could not get index for object: {name}", LogLevel.Warn);
}
if (name is "Wine" or "Jelly" or "Juice" or "Pickle" or "Roe" or "Aged Roe")
{
var preservedGoods = prizeLevel.Flavor;
var item1 = ItemsUtil.GetIndexByName(preservedGoods);
if (item1 == -1)
{
MarketDay.Log($" Could not get index for flavor: {preservedGoods}", LogLevel.Warn);
}
}
}
}
}
public static bool Prefix(Object __instance, GameLocation location, ref bool __result)
{
var owner = MapUtility.Owner(__instance);
MarketDay.Log(
$"Prefix_Object_performToolAction checking {__instance} {__instance.DisplayName} owner {owner} at {__instance.TileLocation}",
LogLevel.Debug, true);
if (MarketDay.Config.RuinTheFurniture)
{
return(true);
}
if (owner is null)
{
return(true);
}
MarketDay.Log(
$"Prefix_Object_performToolAction preventing damage to object at {__instance.TileLocation} owned by {owner}",
LogLevel.Debug, true);
location.playSound("clank");
__instance.shakeTimer = 100;
__result = false;
return(false);
}
public void Succeed()
{
string RequestConvId = "5-562";
string ClientIp = "192.168.1.31";
int ClientPort = 5682;
var testStock = new Stock("TST", "Test Stock");
ValuatedStock[] vStock = { new ValuatedStock(("1984-02-22,1,2,3,100,5").Split(','), testStock) };
MarketDay day = new MarketDay("day1", vStock);
var RequestMessage = new StockPriceUpdate(day)
{
ConversationID = RequestConvId,
};
Envelope Request = new Envelope(RequestMessage, ClientIp, ClientPort);
var localConv = ConversationManager.GetConversation(RequestConvId);
Assert.IsNull(localConv);
Assert.IsNull(mock);
ConversationManager.ProcessIncomingMessage(Request);
localConv = ConversationManager.GetConversation(RequestConvId);
Assert.IsNotNull(localConv);
Assert.IsTrue(localConv.CurrentState is ConversationDoneState);
mock.Verify(state => state.Prepare(), Times.Once);
mock.Verify(state => state.Send(), Times.Once);
mock.Verify(state => state.HandleTimeout(), Times.Never);
}
public void TryParse_returns_false_for_the_header_row()
{
var testData = "Date,Open,High,Low,Close,Adj Close,Volume";
var result = MarketDay.TryParse(testData, out _);
Assert.IsFalse(result);
}
public void TryParse_returns_false_for_null_rows()
{
var testData = "2019-05-05,null,null,null,null,null,null";
var result = MarketDay.TryParse(testData, out _);
Assert.IsFalse(result);
}
public void ValidMarketDaySignatureTest()
{
//Prepare
var stock1 = new ValuatedStock()
{
Symbol = "STK1",
Name = "Stock 1",
Open = 1,
High = 2,
Low = 3,
Close = 4,
Volume = 5
};
var stock2 = new ValuatedStock()
{
Symbol = "STK2",
Name = "Stock 2",
Open = 6,
High = 7,
Low = 8,
Close = 9,
Volume = 10
};
ValuatedStock[] stocks = { stock1, stock2 };
var marketDay = new MarketDay("testDay", stocks);
string signature = SigServe.GetSignature(marketDay);
var isVerified = SigServe.VerifySignature(marketDay, signature);
Assert.IsTrue(isVerified);
}
public void SerializationTest()
{
//Prepare
var stock1 = new ValuatedStock()
{
Symbol = "STK1",
Name = "Stock 1",
Open = 1,
High = 2,
Low = 3,
Close = 4,
Volume = 5
};
var stock2 = new ValuatedStock()
{
Symbol = "STK2",
Name = "Stock 2",
Open = 6,
High = 7,
Low = 8,
Close = 9,
Volume = 10
};
ValuatedStock[] stocks = { stock1, stock2 };
var marketDay = new MarketDay("testDay", stocks);
//Execute
var serialized = SigServe.Serialize(marketDay);
var deserialziedMarketDay = SigServe.Deserialize <MarketDay>(serialized);
//Assert
Assert.IsTrue(deserialziedMarketDay.Equals(marketDay));
}
public void DefaultConstructorTest()
{
var MarketDay = new MarketDay();
Assert.IsNull(MarketDay.TradedCompanies);
Assert.IsNull(MarketDay.Date);
}
/// <summary>
/// Initialize the ItemStock, doing error checking on the quality, and setting the price to the store price
/// if none is given specifically for this stock.
/// Creates the builder
/// </summary>
/// <param name="shopName"></param>
/// <param name="price"></param>
/// <param name="defaultSellPriceMultiplier"></param>
/// <param name="priceMultiplierWhen"></param>
internal void Initialize(string shopName, int price, double defaultSellPriceMultiplier, Dictionary <double, string[]> priceMultiplierWhen)
{
ShopName = shopName;
DefaultSellPriceMultiplier = defaultSellPriceMultiplier;
PriceMultiplierWhen = priceMultiplierWhen;
if (Quality is < 0 or 3 or > 4)
{
Quality = 0;
MarketDay.Log("Item quality can only be 0,1,2, or 4. Defaulting to 0", LogLevel.Warn);
}
CurrencyObjectId = ItemsUtil.GetIndexByName(StockItemCurrency);
//sets price to the store price if no stock price is given
if (StockPrice == -1)
{
StockPrice = price;
}
_priceMultiplierWhen = priceMultiplierWhen;
if (IsRecipe)
{
Stock = 1;
}
_builder = new ItemBuilder(this);
}
public static bool Prefix(Object __instance, GameLocation location, ref bool __result)
{
var owner = MapUtility.Owner(__instance);
MarketDay.Log(
$"Prefix_Object_performUseAction checking {__instance} {__instance.DisplayName} owner {owner} at {__instance.TileLocation}",
LogLevel.Debug, true);
if (owner is null)
{
return(true);
}
if (owner == $"Farmer:{Game1.player.Name}" || MarketDay.Config.PeekIntoChests)
{
return(true);
}
MarketDay.Log(
$"Prefix_Object_performUseAction preventing use of object at {__instance.TileLocation} owned by {owner}",
LogLevel.Debug, true);
location.playSound("clank");
__instance.shakeTimer = 500;
__result = false;
return(false);
}
public void InitializerTest()
{
var stock1 = new ValuatedStock();
var stock2 = new ValuatedStock();
ValuatedStock[] stocks = { stock1, stock2 };
string date1 = "1990-02-20";
string date2 = "1990-03-20";
MarketDay day1 = new MarketDay(date1, stocks);
MarketDay day2 = new MarketDay(date2, stocks);//not important that has same valuated stocks
var recentHistory = new MarketSegment
{
day1,
day2
};
var stockStreamResponse = new StockHistoryResponseMessage
{
RecentHistory = recentHistory
};
Assert.AreEqual(stockStreamResponse.RecentHistory[0].Date, date1);
Assert.AreEqual(stockStreamResponse.RecentHistory[1].Date, date2);
Assert.AreEqual(stockStreamResponse.RecentHistory.Count, 2);
Assert.AreEqual(3, stockStreamResponse.RecentHistory[0].TradedCompanies.Count);
Assert.AreEqual(3, stockStreamResponse.RecentHistory[1].TradedCompanies.Count);
}
public static void Postfix(Chest __instance, SpriteBatch spriteBatch, int x, int y)
{
if (!__instance.modData.TryGetValue($"{MarketDay.SMod.ModManifest.UniqueID}/{GrangeShop.StockChestKey}",
out var ShopKey))
{
return;
}
// get shop for ShopKey
if (!ShopManager.GrangeShops.TryGetValue(ShopKey, out var grangeShop))
{
MarketDay.Log(
$"Postfix_draw: shop '{ShopKey}' not found in ShopManager.GrangeShops, can't draw",
LogLevel.Error);
return;
}
var tileLocation = grangeShop.Origin;
if (tileLocation == Vector2.Zero)
{
return;
}
var drawLayer = Math.Max(0f, (tileLocation.Y * Game1.tileSize - 24) / 10000f) + tileLocation.X * 1E-05f;
grangeShop.drawGrangeItems(tileLocation, spriteBatch, drawLayer);
drawLayer = Math.Max(0f, (tileLocation.Y + 3) * Game1.tileSize / 10000f) + tileLocation.X * 1E-05f;
grangeShop.DrawSign(tileLocation, spriteBatch, drawLayer);
}
/// <summary>
/// Loads the portrait, if it exists, and use the seasonal version if one is found for the current season
/// </summary>
public void UpdatePortrait()
{
if (PortraitPath == null)
{
return;
}
//construct seasonal path to the portrait
string seasonalPath = PortraitPath.Insert(PortraitPath.IndexOf('.'), "_" + Game1.currentSeason);
try
{
//if the seasonal version exists, load it
if (ContentPack.HasFile(seasonalPath))
{
_portrait = ContentPack.ModContent.Load <Texture2D>(seasonalPath);
}
//if the seasonal version doesn't exist, try to load the default
else if (ContentPack.HasFile(PortraitPath))
{
_portrait = ContentPack.ModContent.Load <Texture2D>(PortraitPath);
}
}
catch (Exception ex) //couldn't load the image
{
MarketDay.Log(ex.Message + ex.StackTrace, LogLevel.Error);
}
}
public void DateConstructorTest()
{
string date = "1990-02-20";
var MarketDay = new MarketDay(date);
Assert.AreEqual(1, MarketDay.TradedCompanies.Count);
Assert.AreEqual(MarketDay.Date, date);
}
public ReceiveStockUpdateState(Envelope env, Conversation conversation) : base(env, conversation, null)
{
var update = env.Contents as StockPriceUpdate;
var sigServ = new SignatureService();
var bytes = Convert.FromBase64String(update.SerializedStockList);
StockUpdate = sigServ.Deserialize <MarketDay>(bytes);
}
/// <summary>
/// Resets the items of this item stock, with condition checks and randomization
/// </summary>
/// <returns></returns>
public Dictionary <ISalable, int[]> Update()
{
if (When != null && !APIs.Conditions.CheckConditions(When))
{
return(null); //did not pass conditions
}
if (!ItemsUtil.CheckItemType(ItemType)) //check that itemtype is valid
{
MarketDay.Log($"\t\"{ItemType}\" is not a valid ItemType. No items from this stock will be added."
, LogLevel.Warn);
return(null);
}
_itemPriceAndStock = new Dictionary <ISalable, int[]>();
_builder.SetItemPriceAndStock(_itemPriceAndStock);
double priceMultiplier = 1;
if (_priceMultiplierWhen != null)
{
foreach (KeyValuePair <double, string[]> kvp in _priceMultiplierWhen)
{
if (APIs.Conditions.CheckConditions(kvp.Value))
{
priceMultiplier = kvp.Key;
break;
}
}
}
if (ItemType != "Seed")
{
AddById(priceMultiplier);
AddByName(priceMultiplier);
}
else
{
if (ItemIDs != null)
{
MarketDay.Log(
"ItemType of \"Seed\" is a special itemtype used for parsing Seeds from JA Pack crops and trees and does not support input via ID. If adding seeds via ID, please use the ItemType \"Object\" instead to directly sell the seeds/saplings", LogLevel.Trace);
}
if (ItemNames != null)
{
MarketDay.Log(
"ItemType of \"Seed\" is a special itemtype used for parsing Seeds from JA Pack crops and trees and does not support input via Name. If adding seeds via Name, please use the ItemType \"Object\" instead to directly sell the seeds/saplings", LogLevel.Trace);
}
}
AddByJAPack(priceMultiplier);
ItemsUtil.RandomizeStock(_itemPriceAndStock, MaxNumItemsSoldInItemStock);
return(_itemPriceAndStock);
}
//Bad data added in manaually for testing
public static Portfolio makeupPortfolio(MarketDay input)
{
Portfolio ret = new Portfolio();
foreach (ValuatedStock i in input.TradedCompanies)
{
int count = random.Next(0, 2);
count *= random.Next(0, 100);
ret.Assets.Add(i.Symbol, new Asset(i, count));
}
return(ret);
}
public void LoadedConstructorTest()
{
string date = "1990-02-20";
var stock1 = new ValuatedStock();
var stock2 = new ValuatedStock();
ValuatedStock[] stocks = { stock1, stock2 };
var MarketDay = new MarketDay(date, stocks);
Assert.AreEqual(3, MarketDay.TradedCompanies.Count);
Assert.AreEqual(MarketDay.Date, date);
}
internal static bool Equal(ISalable a, ISalable b)
{
if (a is null || b is null)
{
return(false);
}
var dgaApi = APIs.dgaApi.Value;
if (dgaApi is not null)
{
var aID = dgaApi.GetDGAItemId(a);
var bID = dgaApi.GetDGAItemId(b);
if (aID is not null && bID is not null)
{
return(aID == bID);
}
}
switch (a)
{
case Hat aHat when b is Hat bHat:
return(aHat.which.Value == bHat.which.Value);
case Tool aTool when b is Tool bTool: // includes weapons
return(aTool.InitialParentTileIndex == bTool.InitialParentTileIndex);
case Boots aBoots when b is Boots bBoots:
return(aBoots.indexInTileSheet == bBoots.indexInTileSheet);
case Item aItem when b is Item bItem:
{
if (aItem.ParentSheetIndex > -1 && bItem.ParentSheetIndex > -1)
{
return(aItem.ParentSheetIndex == bItem.ParentSheetIndex && aItem.Category == bItem.Category);
}
break;
}
}
if (a is not Item)
{
MarketDay.Log($"Equal: {a.Name} not an item", LogLevel.Warn);
}
if (b is not Item)
{
MarketDay.Log($"Equal: {b.Name} not an item", LogLevel.Warn);
}
return(a.Name == b.Name);
}
public void Timeout()
{
var conv = new StockUpdateSendConversation(42);
SortedList Records = new SortedList();
var clientEndpoint = new IPEndPoint(IPAddress.Parse("111.11.2.3"), 124);
ValuatedStock[] day1 = { user1VStock, user2VStock, user3VStock };
var mday1 = new MarketDay("day-1", day1);
//LeaderboardManager.Market = new MarketDay("day-1", day1);
//setup response message and mock
var mock = new Mock <StockUpdateSendState>(mday1, clientEndpoint, conv, null)
{
CallBase = true
};
mock.Setup(st => st.Send())//Pretend message is sent and response comes back...
.Callback(() =>
{
//pretend client never responds, do nothing
}).CallBase().Verifiable();
////execute test
conv.SetInitialState(mock.Object as StockUpdateSendState);
Assert.IsTrue(ClientManager.TryToAdd(clientEndpoint));
Assert.IsTrue(conv.CurrentState is StockUpdateSendState);
mock.Verify(state => state.Prepare(), Times.Never);
mock.Verify(state => state.Send(), Times.Never);
ConversationManager.AddConversation(conv);
Assert.IsTrue(conv.CurrentState is StockUpdateSendState);
mock.Verify(state => state.Prepare(), Times.Once);
mock.Verify(state => state.Send(), Times.Once);
mock.Verify(state => state.HandleTimeout(), Times.Never);
Assert.AreEqual(1, ClientManager.Clients.Count);
Thread.Sleep((int)(Config.GetInt(Config.DEFAULT_TIMEOUT) * (Config.GetInt(Config.DEFAULT_RETRY_COUNT) + 1) * 1.1));
Assert.AreEqual(0, ClientManager.Clients.Count);
Assert.IsFalse(conv.CurrentState is StockUpdateSendState);
Assert.IsTrue(conv.CurrentState is ConversationDoneState);
mock.Verify(state => state.HandleMessage(It.IsAny <Envelope>()), Times.Never);
mock.Verify(state => state.Prepare(), Times.Once);
mock.Verify(state => state.Send(), Times.Exactly(3));
mock.Verify(state => state.HandleTimeout(), Times.AtLeast(3));
}
private static void LoadOneMail(string mailKey)
{
var deserializeKey = $"Mail/{mailKey}";
var Text = MarketDay.GetSharedString($"{deserializeKey}/Text");
var player = MarketDay.GetSharedString($"{deserializeKey}/Player");
var TextColor = MarketDay.GetSharedValue($"{deserializeKey}/TextColor");
var whichBG = MarketDay.GetSharedValue($"{deserializeKey}/BG");
var ObjName = MarketDay.GetSharedString($"{deserializeKey}/ObjName");
var Flavor = MarketDay.GetSharedString($"{deserializeKey}/Flavor");
var Stack = MarketDay.GetSharedValue($"{deserializeKey}/Stack");
var Quality = MarketDay.GetSharedValue($"{deserializeKey}/Quality");
if (player is not null && Game1.player.Name != player)
{
return;
}
if (ObjName is not null)
{
MarketDay.Log($"Loading prize mail {mailKey}", LogLevel.Trace);
var attachment = AttachmentForPrizeMail(ObjName, Flavor, Stack, Quality);
MailDao.SaveLetter(
new Letter(mailKey, Text, new List <Item> {
attachment
},
l => !Game1.player.mailReceived.Contains(l.Id),
l => Game1.player.mailReceived.Add(l.Id),
whichBG
)
{
TextColor = TextColor
}
);
}
else
{
MarketDay.Log($"Loading non-prize mail {mailKey}", LogLevel.Trace);
MailDao.SaveLetter(
new Letter(mailKey, Text,
l => !Game1.player.mailReceived.Contains(l.Id),
l => Game1.player.mailReceived.Add(l.Id),
whichBG
)
{
TextColor = TextColor
}
);
}
}
public void LoadKeysTest()
{
//Clear keys from other tests
SignatureService.PublicKey = null;
SignatureService.PrivateKey = null;
Assert.IsNull(SignatureService.PublicKey);
Assert.IsNull(SignatureService.PrivateKey);
//Load Keys
SignatureService.LoadPrivateKey("Team1/StockServer");
SignatureService.LoadPublicKey("Team1/StockServer");
//Prepare a MarketDay
var stock1 = new ValuatedStock()
{
Symbol = "STK1",
Name = "Stock 1",
Open = 1,
High = 2,
Low = 3,
Close = 4,
Volume = 5
};
var stock2 = new ValuatedStock()
{
Symbol = "STK2",
Name = "Stock 2",
Open = 6,
High = 7,
Low = 8,
Close = 9,
Volume = 10
};
ValuatedStock[] stocks = { stock1, stock2 };
var marketDay = new MarketDay("testDay", stocks);
//Sign marketDay
string signature = SigServe.GetSignature(marketDay);
//Verify signature
var isVerified = SigServe.VerifySignature(marketDay, signature);
Assert.IsTrue(isVerified);
}
public void LoadedConstructorTest()
{
var stock1 = new ValuatedStock();
var stock2 = new ValuatedStock();
ValuatedStock[] stocks = { stock1, stock2 };
var date = "1990-02-20";
var marketDay = new MarketDay(date, stocks);
var stockPriceUpdate = new StockPriceUpdate(marketDay);
var StocksList = sigServ.Deserialize <MarketDay>(Convert.FromBase64String(stockPriceUpdate.SerializedStockList));
Assert.AreEqual(3, StocksList.TradedCompanies.Count);
Assert.AreEqual(StocksList.Date, date);
}
public void TryParse_returns_true_for_a_regular_data_row()
{
var testData = "2020-04-30,1729.500000,1737.000000,1687.500000,1695.400024,1695.400024,110088974";
var result = MarketDay.TryParse(testData, out MarketDay marketDay);
var accuracy = 0.001;
Assert.IsTrue(result);
Assert.AreEqual(new DateTime(2020, 4, 30), marketDay.Date);
Assert.AreEqual(1729.5, (double)marketDay.Open, accuracy);
Assert.AreEqual(1737, (double)marketDay.High, accuracy);
Assert.AreEqual(1687.5, (double)marketDay.Low, accuracy);
Assert.AreEqual(1695.400024, (double)marketDay.Close, accuracy);
Assert.AreEqual(1695.400024, (double)marketDay.AdjClose, accuracy);
Assert.AreEqual(110088974, (double)marketDay.Volume, accuracy);
}
public void InitializerTest()
{
string date = "1990-02-20";
var stock1 = new ValuatedStock();
var stock2 = new ValuatedStock();
ValuatedStock[] stocks = { stock1, stock2 };
var MarketDay = new MarketDay
{
Date = date
};
MarketDay.TradedCompanies = stocks.Cast <ValuatedStock>().ToList();
Assert.AreEqual(3, MarketDay.TradedCompanies.Count);
Assert.AreEqual(MarketDay.Date, date);
}
private static Object AttachmentForPrizeMail(string ObjName, string Flavor, int Stack, int Quality = 0)
{
var idx = ItemsUtil.GetIndexByName(ObjName);
if (idx < 0)
{
MarketDay.Log($"Could not find prize object {ObjName}", LogLevel.Error);
idx = 169;
}
var stack = Math.Max(Stack, 1);
var attachment = new Object(idx, stack);
if (Quality is 0 or 1 or 2 or 4)
{
attachment.Quality = Quality;
}
if (Flavor is null || Flavor.Length <= 0)
{
return(attachment);
}
var prIdx = ItemsUtil.GetIndexByName(Flavor);
if (prIdx < 0)
{
MarketDay.Log($"Could not find flavor object {Flavor}", LogLevel.Error);
prIdx = 258;
}
attachment.preservedParentSheetIndex.Value = prIdx;
attachment.preserve.Value = ObjName switch
{
"Wine" => Object.PreserveType.Wine,
"Jelly" => Object.PreserveType.Jelly,
"Juice" => Object.PreserveType.Juice,
"Pickle" => Object.PreserveType.Pickle,
"Roe" => Object.PreserveType.Roe,
"Aged Roe" => Object.PreserveType.AgedRoe,
_ => Object.PreserveType.Jelly
};
return(attachment);
}
}
public void ValidSignatureTest()
{
var key = SignatureService.GenerateKeys(1024);
SignatureService.PublicKey = (RsaKeyParameters)(key.Public);
SignatureService.PrivateKey = (RsaKeyParameters)(key.Private);
var sigServe = new SignatureService();
var stock1 = new ValuatedStock();
var stock2 = new ValuatedStock();
ValuatedStock[] stocks = { stock1, stock2 };
var date = "1990-02-29";
var marketDay = new MarketDay(date, stocks);
var marketDaySig = sigServe.GetSignature(marketDay);
var stockPriceUpdate = new StockPriceUpdate(marketDay)
{
StockListSignature = marketDaySig
};
var isOriginalValid = sigServe.VerifySignature(marketDay, marketDaySig);
Assert.IsTrue(isOriginalValid);
var serializedMessage = stockPriceUpdate.Encode();
var deserializedMessage = MessageFactory.GetMessage(serializedMessage, false) as StockPriceUpdate;
MarketDay deserializedDay = sigServ.Deserialize <MarketDay>(Convert.FromBase64String(deserializedMessage.SerializedStockList));
var StocksList_original = sigServ.Deserialize <MarketDay>(Convert.FromBase64String(stockPriceUpdate.SerializedStockList));
var StocksList_deserialized = sigServ.Deserialize <MarketDay>(Convert.FromBase64String(deserializedMessage.SerializedStockList));
var isDeserializedValid = sigServe.VerifySignature(StocksList_deserialized, deserializedMessage.StockListSignature);
Assert.IsTrue(isDeserializedValid);
Assert.AreEqual(StocksList_original.TradedCompanies.Count, StocksList_deserialized.TradedCompanies.Count);
Assert.AreEqual(StocksList_original.Date, StocksList_deserialized.Date);
Assert.IsTrue(sigServe.VerifySignature(StocksList_deserialized, deserializedMessage.StockListSignature));
}
