Fixed Typo in SendTextMessage method. Removed unneeded async/awaits in Api.

--- Telegram.Bot/Api.cs
+++ Telegram.Bot/Api.cs
@@ -26,7 +26,7 @@
         /// A simple method for testing your bot's auth token. Requires no parameters. Returns basic information about the bot in form of User object.
         /// </summary>
         /// <returns>Returns basic information about the bot in form of <see cref="User"/> object</returns>
-        public async Task<User> GetMe() => await SendWebRequest<User>("getMe").ConfigureAwait(false);
+        public Task<User> GetMe() => SendWebRequest<User>("getMe");

         /// <summary>
         /// Use this method to receive incoming updates using long polling.
@@ -47,7 +47,7 @@
         /// 2. In order to avoid getting duplicate updates, recalculate offset after each server response.
         /// </remarks>
         /// <returns>An Array of Update objects is returned.</returns>
-        public async Task<Update[]> GetUpdates(int offset = 0, int limit = 100, int timeout = 0)
+        public Task<Update[]> GetUpdates(int offset = 0, int limit = 100, int timeout = 0)
         {
             var parameters = new Dictionary<string, object>
             {
@@ -56,7 +56,7 @@
                 {"timeout", timeout}
             };

-            return await SendWebRequest<Update[]>("getUpdates", parameters).ConfigureAwait(false);
+            return SendWebRequest<Update[]>("getUpdates", parameters);
         }

@@ -65,14 +65,14 @@
         /// send an HTTPS POST request to the specified url, containing a JSON-serialized Update. In case of an unsuccessful request, we will
         /// give up after a reasonable amount of attempts.
         /// </summary>
-        /// <param name="url">Optimal. HTTPS url to send updates to. Use an empty string to remove webhook integration</param>
+        /// <param name="url">Optional. HTTPS url to send updates to. Use an empty string to remove webhook integration</param>
         /// <param name="certificate">Upload your public key certificate so that the root certificate in use can be checked</param>
         /// <remarks>
         /// 1. You will not be able to receive updates using getUpdates for as long as an outgoing webhook is set up.
         /// 2. We currently do not support self-signed certificates.
         /// 3. For the moment, the only supported port for Webhooks is 443. We may support additional ports later.
         /// </remarks>
-        public async Task SetWebhook(string url = "", FileToSend? certificate = null)
+        public Task SetWebhook(string url = "", FileToSend? certificate = null)
         {
             var parameters = new Dictionary<string, object>
             {
@@ -82,7 +82,7 @@
             if (certificate != null)
                 parameters.Add("certificate", certificate);

-            await SendWebRequest<bool>("setWebhook", parameters).ConfigureAwait(false);
+            return SendWebRequest<bool>("setWebhook", parameters);
         }

         /// <summary>
@@ -91,11 +91,11 @@
         /// <param name="type">The <see cref="MessageType"/></param>
         /// <param name="chatId">Unique identifier for the target chat or username of the target channel (in the format @channelusername)</param>
         /// <param name="content">The content of the message. Could be a text, photo, audio, sticker, document, video or location</param>
-        /// <param name="replyToMessageId">Optimal. If the message is a reply, ID of the original message</param>
-        /// <param name="replyMarkup">Optimal. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
-        /// <param name="additionalParameters">Optimal. if additional Parameters could bei send i.e. "disable_web_page_preview" in for a TextMessage</param>
-        /// <returns>On success, the sent Message is returned.</returns>
-        private async Task<Message> SendMessage(MessageType type, string chatId, object content,
+        /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
+        /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
+        /// <param name="additionalParameters">Optional. if additional Parameters could bei send i.e. "disable_web_page_preview" in for a TextMessage</param>
+        /// <returns>On success, the sent Message is returned.</returns>
+        private Task<Message> SendMessage(MessageType type, string chatId, object content,
             int replyToMessageId = 0,
             ReplyMarkup replyMarkup = null,
             Dictionary<string, object> additionalParameters = null)
@@ -114,7 +114,7 @@
             if (!string.IsNullOrEmpty(typeInfo.Value))
                 additionalParameters.Add(typeInfo.Value, content);

-            return await SendWebRequest<Message>(typeInfo.Key, additionalParameters).ConfigureAwait(false);
+            return SendWebRequest<Message>(typeInfo.Key, additionalParameters);
         }

         /// <summary>
@@ -122,38 +122,38 @@
         /// </summary>
         /// <param name="chatId">Unique identifier for the target chat</param>
         /// <param name="text">Text of the message to be sent</param>
-        /// <param name="disableWebPagePreview">Optimal. Disables link previews for links in this message</param>
-        /// <param name="replyToMessageId">Optimal. If the message is a reply, ID of the original message</param>
-        /// <param name="replyMarkup">Optimal. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
-        /// <param name="isMardown">Optimal. Set to true if you want Telegram apps to show bold, italic and inline URLs in your message.</param>
-        /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendTextMessage(int chatId, string text, bool disableWebPagePreview = false,
+        /// <param name="disableWebPagePreview">Optional. Disables link previews for links in this message</param>
+        /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
+        /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
+        /// <param name="isMarkdown">Optional. Set to true if you want Telegram apps to show bold, italic and inline URLs in your message.</param>
+        /// <returns>On success, the sent Message is returned.</returns>
+        public Task<Message> SendTextMessage(int chatId, string text, bool disableWebPagePreview = false,
             int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null, bool isMardown = false)
-            => await SendTextMessage(chatId.ToString(), text, disableWebPagePreview, replyToMessageId, replyMarkup, isMardown);
+            ReplyMarkup replyMarkup = null, bool isMarkdown = false)
+            => SendTextMessage(chatId.ToString(), text, disableWebPagePreview, replyToMessageId, replyMarkup, isMarkdown);

         /// <summary>
         /// Use this method to send text messages. On success, the sent Message is returned.
         /// </summary>
         /// <param name="chatId">username of the target channel (in the format @channelusername)</param>
         /// <param name="text">Text of the message to be sent</param>
-        /// <param name="disableWebPagePreview">Optimal. Disables link previews for links in this message</param>
-        /// <param name="replyToMessageId">Optimal. If the message is a reply, ID of the original message</param>
-        /// <param name="replyMarkup">Optimal. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
-        /// <param name="isMardown">Optimal. Set to true if you want Telegram apps to show bold, italic and inline URLs in your message.</param>
-        /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendTextMessage(string chatId, string text, bool disableWebPagePreview = false, int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null, bool isMardown = false)
+        /// <param name="disableWebPagePreview">Optional. Disables link previews for links in this message</param>
+        /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
+        /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
+        /// <param name="isMarkdown">Optional. Set to true if you want Telegram apps to show bold, italic and inline URLs in your message.</param>
+        /// <returns>On success, the sent Message is returned.</returns>
+        public Task<Message> SendTextMessage(string chatId, string text, bool disableWebPagePreview = false, int replyToMessageId = 0,
+            ReplyMarkup replyMarkup = null, bool isMarkdown = false)
         {
             var additionalParameters = new Dictionary<string, object>();

             if (disableWebPagePreview)
                 additionalParameters.Add("disable_web_page_preview", true);

-            if (isMardown)
+            if (isMarkdown)
                 additionalParameters.Add("parse_mode", "Markdown");

-            return await SendMessage(MessageType.TextMessage, chatId, text, replyToMessageId, replyMarkup, additionalParameters).ConfigureAwait(false);
+            return SendMessage(MessageType.TextMessage, chatId, text, replyToMessageId, replyMarkup, additionalParameters);
         }

         /// <summary>
@@ -163,7 +163,7 @@
         /// <param name="fromChatId">Unique identifier for the chat where the original message was sent</param>
         /// <param name="messageId">Unique message identifier</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> ForwardMessage(int chatId, int fromChatId, int messageId) => await ForwardMessage(chatId.ToString(), fromChatId.ToString(), messageId);
+        public Task<Message> ForwardMessage(int chatId, int fromChatId, int messageId) => ForwardMessage(chatId.ToString(), fromChatId.ToString(), messageId);

         /// <summary>
         /// Use this method to forward messages of any kind. On success, the sent Message is returned.
@@ -172,7 +172,7 @@
         /// <param name="fromChatId">channel username in the format @channelusername</param>
         /// <param name="messageId">Unique message identifier</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> ForwardMessage(int chatId, string fromChatId, int messageId) => await ForwardMessage(chatId.ToString(), fromChatId, messageId);
+        public Task<Message> ForwardMessage(int chatId, string fromChatId, int messageId) => ForwardMessage(chatId.ToString(), fromChatId, messageId);

         /// <summary>
         /// Use this method to forward messages of any kind. On success, the sent Message is returned.
@@ -181,7 +181,7 @@
         /// <param name="fromChatId">Unique identifier for the chat where the original message was sent</param>
         /// <param name="messageId">Unique message identifier</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> ForwardMessage(string chatId, int fromChatId, int messageId) => await ForwardMessage(chatId, fromChatId.ToString(), messageId);
+        public Task<Message> ForwardMessage(string chatId, int fromChatId, int messageId) => ForwardMessage(chatId, fromChatId.ToString(), messageId);

         /// <summary>
         /// Use this method to forward messages of any kind. On success, the sent Message is returned.
@@ -190,7 +190,7 @@
         /// <param name="fromChatId">channel username in the format @channelusername</param>
         /// <param name="messageId">Unique message identifier</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> ForwardMessage(string chatId, string fromChatId, int messageId)
+        public Task<Message> ForwardMessage(string chatId, string fromChatId, int messageId)
         {
             var parameters = new Dictionary<string, object>
             {
@@ -199,7 +199,7 @@
                 {"message_id", messageId},
             };

-            return await SendWebRequest<Message>("forwardMessage", parameters).ConfigureAwait(false);
+            return SendWebRequest<Message>("forwardMessage", parameters);
         }

         /// <summary>
@@ -211,9 +211,9 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendPhoto(int chatId, FileToSend photo, string caption = "", int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null)
-            => await SendPhoto(chatId.ToString(), photo, caption, replyToMessageId, replyMarkup);
+        public Task<Message> SendPhoto(int chatId, FileToSend photo, string caption = "", int replyToMessageId = 0,
+            ReplyMarkup replyMarkup = null)
+            => SendPhoto(chatId.ToString(), photo, caption, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send photos. On success, the sent Message is returned.
@@ -224,7 +224,7 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendPhoto(string chatId, FileToSend photo, string caption = "", int replyToMessageId = 0,
+        public Task<Message> SendPhoto(string chatId, FileToSend photo, string caption = "", int replyToMessageId = 0,
             ReplyMarkup replyMarkup = null)
         {
             var additionalParameters = new Dictionary<string, object>
@@ -232,7 +232,7 @@
                 {"caption", caption}
             };

-            return await SendMessage(MessageType.PhotoMessage, chatId, photo, replyToMessageId, replyMarkup, additionalParameters).ConfigureAwait(false);
+            return SendMessage(MessageType.PhotoMessage, chatId, photo, replyToMessageId, replyMarkup, additionalParameters);
         }

         /// <summary>
@@ -244,9 +244,9 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendPhoto(int chatId, string photo, string caption = "", int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null)
-            => await SendPhoto(chatId.ToString(), photo, caption, replyToMessageId, replyMarkup);
+        public Task<Message> SendPhoto(int chatId, string photo, string caption = "", int replyToMessageId = 0,
+            ReplyMarkup replyMarkup = null)
+            => SendPhoto(chatId.ToString(), photo, caption, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send photos. On success, the sent Message is returned.
@@ -257,7 +257,7 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendPhoto(string chatId, string photo, string caption = "", int replyToMessageId = 0,
+        public Task<Message> SendPhoto(string chatId, string photo, string caption = "", int replyToMessageId = 0,
             ReplyMarkup replyMarkup = null)
         {
             var additionalParameters = new Dictionary<string, object>
@@ -265,7 +265,7 @@
                 {"caption", caption}
             };

-            return await SendMessage(MessageType.PhotoMessage, chatId, photo, replyToMessageId, replyMarkup, additionalParameters).ConfigureAwait(false);
+            return SendMessage(MessageType.PhotoMessage, chatId, photo, replyToMessageId, replyMarkup, additionalParameters);
         }

         /// <summary>
@@ -279,10 +279,10 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendAudio(int chatId, FileToSend audio, int duration, string performer, string title,
+        public Task<Message> SendAudio(int chatId, FileToSend audio, int duration, string performer, string title,
             int replyToMessageId = 0,
             ReplyMarkup replyMarkup = null)
-            => await SendAudio(chatId.ToString(), audio, duration, performer, title, replyToMessageId, replyMarkup);
+            => SendAudio(chatId.ToString(), audio, duration, performer, title, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send audio files, if you want Telegram clients to display them in the music player. Your audio must be in the .mp3 format. On success, the sent Message is returned. Bots can currently send audio files of up to 50 MB in size, this limit may be changed in the future.
@@ -295,7 +295,7 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendAudio(string chatId, FileToSend audio, int duration, string performer, string title, int replyToMessageId = 0,
+        public Task<Message> SendAudio(string chatId, FileToSend audio, int duration, string performer, string title, int replyToMessageId = 0,
             ReplyMarkup replyMarkup = null)
         {
             var additionalParameters = new Dictionary<string, object>
@@ -305,7 +305,7 @@
                 {"title", title}
             };

-            return await SendMessage(MessageType.AudioMessage, chatId, audio, replyToMessageId, replyMarkup, additionalParameters).ConfigureAwait(false);
+            return SendMessage(MessageType.AudioMessage, chatId, audio, replyToMessageId, replyMarkup, additionalParameters);
         }

         /// <summary>
@@ -319,10 +319,10 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendAudio(int chatId, string audio, int duration, string performer, string title,
+        public Task<Message> SendAudio(int chatId, string audio, int duration, string performer, string title,
             int replyToMessageId = 0,
             ReplyMarkup replyMarkup = null)
-            => await SendAudio(chatId.ToString(), audio, duration, performer, title, replyToMessageId, replyMarkup);
+            => SendAudio(chatId.ToString(), audio, duration, performer, title, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send audio files, if you want Telegram clients to display the file as a playable voice message. For this to work, your audio must be in an .ogg file encoded with OPUS (other formats may be sent as Document). On success, the sent Message is returned. Bots can send audio files of up to 50 MB in size.
@@ -335,7 +335,7 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendAudio(string chatId, string audio, int duration, string performer, string title, int replyToMessageId = 0,
+        public Task<Message> SendAudio(string chatId, string audio, int duration, string performer, string title, int replyToMessageId = 0,
             ReplyMarkup replyMarkup = null)
         {
             var additionalParameters = new Dictionary<string, object>
@@ -345,7 +345,7 @@
                 {"title", title}
             };

-            return await SendMessage(MessageType.AudioMessage, chatId, audio, replyToMessageId, replyMarkup, additionalParameters).ConfigureAwait(false);
+            return SendMessage(MessageType.AudioMessage, chatId, audio, replyToMessageId, replyMarkup, additionalParameters);
         }

         /// <summary>
@@ -356,8 +356,8 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendDocument(int chatId, FileToSend document, int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null) => await SendMessage(MessageType.DocumentMessage, chatId.ToString(), document, replyToMessageId, replyMarkup).ConfigureAwait(false);
+        public Task<Message> SendDocument(int chatId, FileToSend document, int replyToMessageId = 0,
+            ReplyMarkup replyMarkup = null) => SendMessage(MessageType.DocumentMessage, chatId.ToString(), document, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send general files. On success, the sent Message is returned. Bots can send files of any type of up to 50 MB in size.
@@ -367,8 +367,8 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendDocument(string chatId, FileToSend document, int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null) => await SendMessage(MessageType.DocumentMessage, chatId, document, replyToMessageId, replyMarkup).ConfigureAwait(false);
+        public Task<Message> SendDocument(string chatId, FileToSend document, int replyToMessageId = 0,
+            ReplyMarkup replyMarkup = null) => SendMessage(MessageType.DocumentMessage, chatId, document, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send general files. On success, the sent Message is returned. Bots can send files of any type of up to 50 MB in size.
@@ -378,8 +378,8 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendDocument(int chatId, string document, int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null) => await SendMessage(MessageType.DocumentMessage, chatId.ToString(), document, replyToMessageId, replyMarkup).ConfigureAwait(false);
+        public Task<Message> SendDocument(int chatId, string document, int replyToMessageId = 0,
+            ReplyMarkup replyMarkup = null) => SendMessage(MessageType.DocumentMessage, chatId.ToString(), document, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send general files. On success, the sent Message is returned. Bots can send files of any type of up to 50 MB in size.
@@ -389,8 +389,8 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendDocument(string chatId, string document, int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null) => await SendMessage(MessageType.DocumentMessage, chatId, document, replyToMessageId, replyMarkup).ConfigureAwait(false);
+        public Task<Message> SendDocument(string chatId, string document, int replyToMessageId = 0,
+            ReplyMarkup replyMarkup = null) => SendMessage(MessageType.DocumentMessage, chatId, document, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send .webp stickers. On success, the sent Message is returned.
@@ -400,8 +400,8 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendSticker(int chatId, FileToSend sticker, int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null) => await SendMessage(MessageType.StickerMessage, chatId.ToString(), sticker, replyToMessageId, replyMarkup).ConfigureAwait(false);
+        public Task<Message> SendSticker(int chatId, FileToSend sticker, int replyToMessageId = 0,
+            ReplyMarkup replyMarkup = null) => SendMessage(MessageType.StickerMessage, chatId.ToString(), sticker, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send .webp stickers. On success, the sent Message is returned.
@@ -411,8 +411,8 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendSticker(string chatId, FileToSend sticker, int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null) => await SendMessage(MessageType.StickerMessage, chatId, sticker, replyToMessageId, replyMarkup).ConfigureAwait(false);
+        public Task<Message> SendSticker(string chatId, FileToSend sticker, int replyToMessageId = 0,
+            ReplyMarkup replyMarkup = null) => SendMessage(MessageType.StickerMessage, chatId, sticker, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send .webp stickers. On success, the sent Message is returned.
@@ -422,8 +422,8 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendSticker(int chatId, string sticker, int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null) => await SendMessage(MessageType.StickerMessage, chatId.ToString(), sticker, replyToMessageId, replyMarkup).ConfigureAwait(false);
+        public Task<Message> SendSticker(int chatId, string sticker, int replyToMessageId = 0,
+            ReplyMarkup replyMarkup = null) => SendMessage(MessageType.StickerMessage, chatId.ToString(), sticker, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send .webp stickers. On success, the sent Message is returned.
@@ -433,8 +433,8 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendSticker(string chatId, string sticker, int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null) => await SendMessage(MessageType.StickerMessage, chatId, sticker, replyToMessageId, replyMarkup).ConfigureAwait(false);
+        public Task<Message> SendSticker(string chatId, string sticker, int replyToMessageId = 0,
+            ReplyMarkup replyMarkup = null) => SendMessage(MessageType.StickerMessage, chatId, sticker, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send video files, Telegram clients support mp4 videos (other formats may be sent as Document). On success, the sent Message is returned. Bots can send video files of up to 50 MB in size.
@@ -446,10 +446,10 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendVideo(int chatId, FileToSend video, int duration = 0, string caption = "",
+        public Task<Message> SendVideo(int chatId, FileToSend video, int duration = 0, string caption = "",
             int replyToMessageId = 0,
             ReplyMarkup replyMarkup = null)
-            => await SendVideo(chatId.ToString(), video, duration, caption, replyToMessageId, replyMarkup);
+            => SendVideo(chatId.ToString(), video, duration, caption, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send video files, Telegram clients support mp4 videos (other formats may be sent as Document). On success, the sent Message is returned. Bots can send video files of up to 50 MB in size.
@@ -461,7 +461,7 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendVideo(string chatId, FileToSend video, int duration = 0, string caption = "", int replyToMessageId = 0,
+        public Task<Message> SendVideo(string chatId, FileToSend video, int duration = 0, string caption = "", int replyToMessageId = 0,
             ReplyMarkup replyMarkup = null)
         {
             var additionalParameters = new Dictionary<string, object>
@@ -470,7 +470,7 @@
                 {"caption", caption}
             };

-            return await SendMessage(MessageType.VideoMessage, chatId, video, replyToMessageId, replyMarkup, additionalParameters).ConfigureAwait(false);
+            return SendMessage(MessageType.VideoMessage, chatId, video, replyToMessageId, replyMarkup, additionalParameters);
         }

         /// <summary>
@@ -483,10 +483,10 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendVideo(int chatId, string video, int duration = 0, string caption = "",
+        public Task<Message> SendVideo(int chatId, string video, int duration = 0, string caption = "",
             int replyToMessageId = 0,
             ReplyMarkup replyMarkup = null)
-            => await SendVideo(chatId.ToString(), video, duration, caption, replyToMessageId, replyMarkup);
+            => SendVideo(chatId.ToString(), video, duration, caption, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send video files, Telegram clients support mp4 videos (other formats may be sent as Document). On success, the sent Message is returned. Bots can send video files of up to 50 MB in size.
@@ -498,7 +498,7 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendVideo(string chatId, string video, int duration = 0, string caption = "", int replyToMessageId = 0,
+        public Task<Message> SendVideo(string chatId, string video, int duration = 0, string caption = "", int replyToMessageId = 0,
             ReplyMarkup replyMarkup = null)
         {
             var additionalParameters = new Dictionary<string, object>
@@ -507,7 +507,7 @@
                 {"caption", caption}
             };

-            return await SendMessage(MessageType.VideoMessage, chatId, video, replyToMessageId, replyMarkup, additionalParameters).ConfigureAwait(false);
+            return SendMessage(MessageType.VideoMessage, chatId, video, replyToMessageId, replyMarkup, additionalParameters);
         }

         /// <summary>
@@ -519,9 +519,9 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendVoice(int chatId, FileToSend audio, int duration = 0, int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null)
-            => await SendVoice(chatId.ToString(), audio, duration, replyToMessageId, replyMarkup);
+        public Task<Message> SendVoice(int chatId, FileToSend audio, int duration = 0, int replyToMessageId = 0,
+            ReplyMarkup replyMarkup = null)
+            => SendVoice(chatId.ToString(), audio, duration, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send audio files, if you want Telegram clients to display the file as a playable voice message. For this to work, your audio must be in an .ogg file encoded with OPUS (other formats may be sent as Audio or Document). On success, the sent Message is returned. Bots can currently send voice messages of up to 50 MB in size, this limit may be changed in the future.
@@ -532,7 +532,7 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendVoice(string chatId, FileToSend audio, int duration = 0, int replyToMessageId = 0,
+        public Task<Message> SendVoice(string chatId, FileToSend audio, int duration = 0, int replyToMessageId = 0,
             ReplyMarkup replyMarkup = null)
         {
             var additionalParameters = new Dictionary<string, object>
@@ -540,7 +540,7 @@
                 {"duration", duration}
             };

-            return await SendMessage(MessageType.VideoMessage, chatId, audio, replyToMessageId, replyMarkup, additionalParameters).ConfigureAwait(false);
+            return SendMessage(MessageType.VideoMessage, chatId, audio, replyToMessageId, replyMarkup, additionalParameters);
         }

         /// <summary>
@@ -552,9 +552,9 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendVoice(int chatId, string audio, int duration = 0, int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null)
-            => await SendVoice(chatId.ToString(), audio, duration, replyToMessageId, replyMarkup);
+        public Task<Message> SendVoice(int chatId, string audio, int duration = 0, int replyToMessageId = 0,
+            ReplyMarkup replyMarkup = null)
+            => SendVoice(chatId.ToString(), audio, duration, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send audio files, if you want Telegram clients to display the file as a playable voice message. For this to work, your audio must be in an .ogg file encoded with OPUS (other formats may be sent as Audio or Document). On success, the sent Message is returned. Bots can currently send voice messages of up to 50 MB in size, this limit may be changed in the future.
@@ -565,7 +565,7 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendVoice(string chatId, string audio, int duration = 0, int replyToMessageId = 0,
+        public Task<Message> SendVoice(string chatId, string audio, int duration = 0, int replyToMessageId = 0,
             ReplyMarkup replyMarkup = null)
         {
             var additionalParameters = new Dictionary<string, object>
@@ -573,7 +573,7 @@
                 {"duration", duration}
             };

-            return await SendMessage(MessageType.VideoMessage, chatId, audio, replyToMessageId, replyMarkup, additionalParameters).ConfigureAwait(false);
+            return SendMessage(MessageType.VideoMessage, chatId, audio, replyToMessageId, replyMarkup, additionalParameters);
         }

         /// <summary>
@@ -585,9 +585,9 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendLocation(int chatId, float latitude, float longitude, int replyToMessageId = 0,
-            ReplyMarkup replyMarkup = null)
-            => await SendLocation(chatId.ToString(), latitude, longitude, replyToMessageId, replyMarkup);
+        public Task<Message> SendLocation(int chatId, float latitude, float longitude, int replyToMessageId = 0,
+            ReplyMarkup replyMarkup = null)
+            => SendLocation(chatId.ToString(), latitude, longitude, replyToMessageId, replyMarkup);

         /// <summary>
         /// Use this method to send point on the map. On success, the sent Message is returned.
@@ -598,7 +598,7 @@
         /// <param name="replyToMessageId">Optional. If the message is a reply, ID of the original message</param>
         /// <param name="replyMarkup">Optional. Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user.</param>
         /// <returns>On success, the sent Message is returned.</returns>
-        public async Task<Message> SendLocation(string chatId, float latitude, float longitude, int replyToMessageId = 0,
+        public Task<Message> SendLocation(string chatId, float latitude, float longitude, int replyToMessageId = 0,
             ReplyMarkup replyMarkup = null)
         {
             var additionalParameters = new Dictionary<string, object>
@@ -606,7 +606,7 @@
                 {"longitude", longitude},
             };

-            return await SendMessage(MessageType.LocationMessage, chatId, latitude, replyToMessageId, replyMarkup, additionalParameters).ConfigureAwait(false);
+            return SendMessage(MessageType.LocationMessage, chatId, latitude, replyToMessageId, replyMarkup, additionalParameters);
         }

         /// <summary>
@@ -615,8 +615,8 @@
         /// <param name="chatId">Unique identifier for the target chat</param>
         /// <param name="chatAction">Type of action to broadcast. Choose one, depending on what the user is about to receive.</param>
         /// <remarks>We only recommend using this method when a response from the bot will take a noticeable amount of time to arrive.</remarks>
-        public async Task SendChatAction(int chatId, ChatAction chatAction)
-            => await SendChatAction(chatId.ToString(), chatAction);
+        public Task SendChatAction(int chatId, ChatAction chatAction)
+            => SendChatAction(chatId.ToString(), chatAction);

         /// <summary>
         /// Use this method when you need to tell the user that something is happening on the bot's side. The status is set for 5 seconds or less (when a message arrives from your bot, Telegram clients clear its typing status).
@@ -624,7 +624,7 @@
         /// <param name="chatId">Username of the target channel (in the format @channelusername)</param>
         /// <param name="chatAction">Type of action to broadcast. Choose one, depending on what the user is about to receive.</param>
         /// <remarks>We only recommend using this method when a response from the bot will take a noticeable amount of time to arrive.</remarks>
-        public async Task SendChatAction(string chatId, ChatAction chatAction)
+        public Task SendChatAction(string chatId, ChatAction chatAction)
         {
             var parameters = new Dictionary<string, object>
             {
@@ -632,7 +632,7 @@
                 {"action", chatAction.ToActionString()}
             };

-            await SendWebRequest<bool>("sendChatAction", parameters).ConfigureAwait(false);
+            return SendWebRequest<bool>("sendChatAction", parameters);
         }

         /// <summary>
@@ -642,7 +642,7 @@
         /// <param name="offset">Optional. Sequential number of the first photo to be returned. By default, all photos are returned.</param>
         /// <param name="limit">Optional. Limits the number of photos to be retrieved. Values between 1—100 are accepted. Defaults to 100.</param>
         /// <returns></returns>
-        public async Task<UserProfilePhotos> GetUserProfilePhotos(int userId, int? offset = null, int limit = 100)
+        public Task<UserProfilePhotos> GetUserProfilePhotos(int userId, int? offset = null, int limit = 100)
         {
             var parameters = new Dictionary<string, object>
             {
@@ -651,7 +651,7 @@
                 {"limit", limit}
             };

-            return await SendWebRequest<UserProfilePhotos>("getUserProfilePhotos", parameters).ConfigureAwait(false);
+            return SendWebRequest<UserProfilePhotos>("getUserProfilePhotos", parameters);
         }

         /// <summary>


Delete IMessageQueue.cs

Delete IMessageQueue.cs

--- src/Messaging/IMessageQueue.cs
+++ src/Messaging/IMessageQueue.cs
@@ -1,58 +0,0 @@
-/****************************************************************************/
-/*                                                                          */
-/*    The Mondo Libraries  							                        */
-/*                                                                          */
-/*        Namespace: Mondo.Common							                */
-/*             File: IMessageQueue.cs										*/
-/*        Class(es): IMessageQueue				  				            */
-/*          Purpose: Interface for message queues                           */
-/*                                                                          */
-/*  Original Author: Jim Lightfoot                                          */
-/*    Creation Date: 8 Nov 2015                                             */
-/*                                                                          */
-/*   Copyright (c) 2015 - Jim Lightfoot,  All rights reserved               */
-/*                                                                          */
-/*  Licensed under the MIT license:                                         */
-/*    http://www.opensource.org/licenses/mit-license.php                    */
-/*                                                                          */
-/****************************************************************************/
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using System.Xml;
-
-namespace Mondo.Common
-{
-    /****************************************************************************/
-    /****************************************************************************/
-    public interface IMessageQueue
-    {
-        void SendMessage(string message);
-        void Clear();
-
-        Task ProcessMessagesAsync(IMessageProcessor processor, CancellationToken cancelToken);
-        void ProcessMessages(IMessageProcessor processor, CancellationToken cancelToken);
-    }
-
-    /****************************************************************************/
-    /****************************************************************************/
-    public interface IMessageBatch : IDisposable
-    {
-        string Id { get; }
-    }
-
-    /****************************************************************************/
-    /****************************************************************************/
-    public interface IMessageProcessor
-    {
-        void ProcessMessage(string message, IMessageBatch batch);
-
-        bool HandleMessageError(Exception ex, string message);
-
-        IMessageBatch StartBatch();
-    }
-}


Added function to output a file Need to write an import

--- Assets/Scripts/Controller.cs
+++ Assets/Scripts/Controller.cs
@@ -19,9 +19,19 @@
 	public List<Edge> edges;		/**< Keeps track of all our edges */
 	public List<MegaNode> megas;	/**< Keeps track of all our mega nodes */

-	public string file;				/**< File name of the .mtx file in the Assets/Matrices folder we want. EG "qh882"*/
+	/**
+		File name of the matrix file we want to Load.
+		Should NOT include the file ending (.mtx / .mtxs)
+		For .mtx files, file name will be relative to Assets/Matrices
+		For .mtxs files, file name will be relative to Assets/SolvedMatrices
+		For a .mtxs file, the boolean solved should be true.
+		For normal .mtx files, solved should be false.
+		EG "qh882" or "sub2k/can_229"
+	*/
+	public string file;
+	public bool solved;				/**< Are we loading a solved .mtxs (true) or a .mtx (false)? */
 	public float dt;					/**< Delta Time variable. Should being at around 1, and will automatically be reduced as the simulation continues. */
-	public float colorFactor;		/**< Multiplier that affects how the colors are mapped to the gradient. Recommended value of 3 */
+	public float colorFactor;		/**< Multiplier that affects how the colors are mapped to the gradient. Recommended value of 2 */
 	public int initialPositionStyle;	/**< Defines distrubution of the nodes when first created. 0 = position in matrix, 1 = square, 2 = cube, 3 = randomized sphere */
 	public bool simplify;			/**< If true, the graph is simplified before beginning simulation. It will unsimplify during the simulation */
 	public float nodeFScale;		/**< Value that determines Node.forceScale during simulation. You can change it through the inspector during a simulation */
@@ -596,6 +606,7 @@
 						upNodes=false;
 						simulating = false;
 						framesUntilCheck = 50;
+						saveSolvedFile();
 					}else
 					{

@@ -623,6 +634,41 @@
 	}

 	/**
+		Saves a file that denotes the "solved" positions of the nodes
+		Name of the file will be the same as the unsolved, but with fileType .mtxs
+
+		Line 1 will have the number of nodes and edges
+		Next will be all the nodes: index ID position.x,position.y,position.z
+		Then the Edges: index1 index2
+
+	*/
+	void saveSolvedFile(){
+		string path = Application.dataPath+"/SolvedMatrices/"+file+".mtxs";
+		//If it's already been saved, don't bother saving it again
+		if(File.Exists(path))
+		{
+			return;
+		}
+
+		//Put together the file
+		string fileData = nodes.Count+" "+edges.Count;
+
+		for(int i=0;i<nodes.Count;i++)
+		{
+			Vector3 pos = nodes[i].t.localPosition;
+			fileData += "\n"+i+" "+nodes[i].id+" "+
+				pos.x.ToString("#.000")+","+pos.y.ToString("#.000")+","+pos.z.ToString("#.000");
+		}
+
+		for(int i=0;i<edges.Count;i++)
+		{
+			fileData += "\n"+edges[i].node1.index+" "+edges[i].node2.index;
+		}
+
+		File.WriteAllText(path, fileData);
+	}
+
+	/**
 		Unsimplifies graph
 		just calls StopSim() on  active mega nodes over time
 	*/


FileTarget - Zip compression should not truncate when zip-file already exists (skip retry) (#4956)

--- src/NLog/Targets/FileTarget.cs
+++ src/NLog/Targets/FileTarget.cs
@@ -1295,6 +1295,9 @@
                     if (i == fileCompressRetryCount)
                         throw;

+                    if (File.Exists(archiveFileName))
+                        throw;
+
                     int sleepTimeMs = i * 50;
                     InternalLogger.Warn("{0}: Attempt #{1} to compress {2} to {3} failed - {4} {5}. Sleeping for {6}ms", this, i, fileName, archiveFileName, ex.GetType(), ex.Message, sleepTimeMs);
                     AsyncHelpers.WaitForDelay(TimeSpan.FromMilliseconds(sleepTimeMs));


Initialize: cleanup

Initialize: cleanup

--- Assets/Scripts/Initialize.cs
+++ Assets/Scripts/Initialize.cs
@@ -4,10 +4,6 @@
 using UnityEngine.UI;
 using System.Collections.Generic;
 using System.Text;
-#if (NETFX_CORE)
-using Assets.MapzenGo.Models.Enums;
-using Assets.Scripts.Utils;
-#endif

 public class Initialize : MonoBehaviour
 {
@@ -102,9 +98,6 @@

     void InitSpeech()
     {
-
-
-
         audioCommands.Add("Hide Commands", " Hides the voice commands");
         appState.Speech.Keywords.Add("Hide Commands", () =>
         {
@@ -127,7 +120,6 @@

     void InitViews()
     {
-
         appState.Config.Views.ForEach(v =>
         {
             var cmd = SwitchToSpeech + v.Name;
@@ -145,12 +137,6 @@
     // Update is called once per frame
     void Update()
     {
-        //if (Input.GetKeyDown(KeyCode.LeftArrow)) appState.Center = new Vector3(-1, 0, 0);
-        //if (Input.GetKeyDown(KeyCode.RightArrow)) appState.Center = new Vector3(1, 0, 0);
-        //if (Input.GetKeyDown(KeyCode.DownArrow)) appState.Center = new Vector3(0, 0, -1);
-        //if (Input.GetKeyDown(KeyCode.UpArrow)) appState.Center = new Vector3(0, 0, 1);
-        //if (Input.GetKeyDown(KeyCode.I)) appState.Center = new Vector3(0, 1, 0);
-        //if (Input.GetKeyDown(KeyCode.O)) appState.Center = new Vector3(0, -1, 0);
         if (Input.GetKeyDown(KeyCode.C))
         {
             appState.ClearCache();


renmam,es

renmam,es

--- src/OpenInApp.Menu/MenuCore.cs
+++ src/OpenInApp.Menu/MenuCore.cs
@@ -22,7 +22,7 @@
         private readonly KeyToExecutableEnum _keyToExecutableEnum;
         private readonly string _actualPathToExe;
         private readonly string _fileQuantityWarningLimit;
-        private readonly string _keyToExecutableEnumDotDescription;
+        private readonly string _keyToExecutableEnumDescription;
         private readonly string _typicalFileExtensions;
         private readonly string _vsixName;
         private readonly string _vsixVersion;
@@ -30,7 +30,7 @@
         public MenuCore(
                 string vsixName,
                 string vsixVersion,
-                string packageGuidsDotGuidOpenInVsCmdSetString,
+                string guidOpenInVsCmdSetString,
                 int cmdIdOpenInAppFolderExplore,
                 int cmdIdOpenInAppCodeWin,
                 int? cmdIdOpenInAppFolderNode,
@@ -39,7 +39,7 @@
                 string fileQuantityWarningLimit,
                 bool suppressTypicalFileExtensionsWarning,
                 string typicalFileExtensions,
-                string keyToExecutableEnumDotDescription,
+                string keyToExecutableEnumDescription,
                 IServiceProvider serviceProvider,
                 IGeneralOptionsBase generalOptions)
         {
@@ -51,13 +51,13 @@
             _fileQuantityWarningLimit = fileQuantityWarningLimit;
             _generalOptions = generalOptions;
             _keyToExecutableEnum = keyToExecutableEnum;
-            _keyToExecutableEnumDotDescription = keyToExecutableEnumDotDescription;
+            _keyToExecutableEnumDescription = keyToExecutableEnumDescription;
             _serviceProvider = serviceProvider;
             _suppressTypicalFileExtensionsWarning = suppressTypicalFileExtensionsWarning;
             _typicalFileExtensions = typicalFileExtensions;
             _vsixName = vsixName;
             _vsixVersion = vsixVersion;
-            CommandSet = new Guid(packageGuidsDotGuidOpenInVsCmdSetString);
+            CommandSet = new Guid(guidOpenInVsCmdSetString);
         }

         public void MenuCoreOpenInAppCommand(Package package)
@@ -143,7 +143,7 @@
                 _typicalFileExtensions,
                 _constantsForAppCommon.Caption,
                 applicationToOpenDto,
-                _keyToExecutableEnumDotDescription);
+                _keyToExecutableEnumDescription);

             var persistOptionsDto = menuItemCallBackHelper.InvokeCommandCallBack(invokeCommandCallBackDto);


Remove unused options class

Remove unused options class

--- src/Pfim.Benchmarks/Options.cs
+++ src/Pfim.Benchmarks/Options.cs
@@ -1,10 +0,0 @@
-using CommandLine;
-
-namespace Pfim.Benchmarks
-{
-    class Options
-    {
-        [Option]
-        public string Filter { get; set; }
-    }
-}


Incremented version

Incremented version

--- src/Properties/AssemblyInfo.cs
+++ src/Properties/AssemblyInfo.cs
@@ -31,5 +31,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyVersion("1.1.0.0")]
+[assembly: AssemblyFileVersion("1.1.0.0")]


red: added ExampleFeature.FormattedSteps to v2

--- src/test/Xbehave.Features.Net40/ExampleFeature.cs
+++ src/test/Xbehave.Features.Net40/ExampleFeature.cs
@@ -105,7 +105,6 @@
                 .And(() => results.Should().OnlyContain(result => result.DisplayName.Contains("<Int32, Int64, String, Object, Object>")));
         }

-#if !V2
         [Scenario]
         public static void FormattedSteps(Type feature, IEnumerable<Result> results)
         {
@@ -122,6 +121,7 @@
                 .And(() => results.Single().DisplayName.Should().EndWith("Given 1, 2 and 3"));
         }

+#if !V2
         [Scenario]
         public static void FormattedStepsWithNullValues(Type feature, IEnumerable<Result> results)
         {
@@ -280,7 +280,6 @@
             }
         }

-#if !V2
         private static class FeatureWithAScenarioWithExampleValuesAndAFormattedStep
         {
             [Scenario]
@@ -292,6 +291,7 @@
             }
         }

+#if !V2
         private static class FeatureWithAScenarioWithNullExampleValuesAndAFormattedStep
         {
             [Scenario]


make quick sort work on array instead of lists

--- l6.1/ex3/Program.cs
+++ l6.1/ex3/Program.cs
@@ -34,6 +34,11 @@
         // 1
         public static void MyForEach<T>(this IEnumerable<T> source, Action<T> fn)
         {
+            if (source == null)
+            {
+                throw new ArgumentNullException("source");
+            }
+
             foreach (T element in source)
             {
                 fn(element);
@@ -43,6 +48,11 @@
         //2
         public static IEnumerable<T> Filter<T>(this IEnumerable<T> source, Predicate<T> fn)
         {
+            if (source == null)
+            {
+                throw new ArgumentNullException("source");
+            }
+
             foreach (T element in source)
             {
                 if (fn(element))
@@ -56,6 +66,11 @@
         public static T MyMax<T>(this IEnumerable<T> source)
             where T : IComparable
         {
+            if (source == null)
+            {
+                throw new ArgumentNullException("source");
+            }
+
             T max;

             using (var enumerator = source.GetEnumerator())
@@ -84,6 +99,11 @@
         //4
         public static IEnumerable<U> Map<T, U>(this IEnumerable<T> source, Func<T, U> fn)
         {
+            if (source == null)
+            {
+                throw new ArgumentNullException("source");
+            }
+
             foreach (T element in source)
             {
                 yield return fn(element);
@@ -95,6 +115,11 @@
         public static IEnumerable<T> Sorted<T>(this IEnumerable<T> source)
             where T : IComparable
         {
+            if (source == null)
+            {
+                throw new ArgumentNullException("source");
+            }
+
             var list = source.ToList();
             for (int i = 0; list.Count > 0; i++)
             {
@@ -111,59 +136,73 @@
             }
         }

-

         // http://en.wikipedia.org/wiki/Quicksort#In-place_version
         public static IEnumerable<T> QSorted<T>(this IEnumerable<T> source)
             where T : IComparable
         {
-            var list = source.ToList();
-            Quicksort(list, 0, list.Count - 1);
-            return list;
-        }
-
-        private static void Quicksort<T>(List<T> list, int left, int right)
+            if (source == null)
+            {
+                throw new ArgumentNullException("source");
+            }
+
+            var list = source.ToArray();
+            Quicksort(list, 0, list.Length - 1);
+
+            foreach (var element in list)
+            {
+                yield return element;
+            }
+
+        }
+
+        private static void Quicksort<T>(T[] array, int left, int right)
             where T : IComparable
         {
             if (left < right)
             {
                 int pivotIndex = new Random().Next(left, right + 1);
-                int pivotNewIndex = Partition(list, left, right, pivotIndex);
-                Quicksort(list, left, pivotNewIndex - 1);
-                Quicksort(list, pivotNewIndex + 1, right);
-            }
-        }
-
-        private static int Partition<T>(List<T> list, int left, int right, int pivotIndex)
-            where T : IComparable
-        {
-            T pivotValue = list[pivotIndex];
-
-            T temp = list[pivotIndex];
-            list[pivotIndex] = list[right];
-            list[right] = temp;
+                int pivotNewIndex = Partition(array, left, right, pivotIndex);
+                Quicksort(array, left, pivotNewIndex - 1);
+                Quicksort(array, pivotNewIndex + 1, right);
+            }
+        }
+
+        private static int Partition<T>(T[] array, int left, int right, int pivotIndex)
+            where T : IComparable
+        {
+            T pivotValue = array[pivotIndex];
+
+            T temp = array[pivotIndex];
+            array[pivotIndex] = array[right];
+            array[right] = temp;

             int storeIndex = left;
             for (int i = left; i < right; i++)
 			{
-			    if (list[i].CompareTo(pivotValue) <= 0)
+			    if (array[i].CompareTo(pivotValue) <= 0)
 	            {
-		            temp = list[i];
-                    list[i] = list[storeIndex];
-                    list[storeIndex] = temp;
+		            temp = array[i];
+                    array[i] = array[storeIndex];
+                    array[storeIndex] = temp;

                     storeIndex++;
 	            }
 			}

-            temp = list[right];
-            list[right] = list[storeIndex];
-            list[storeIndex] = temp;
+            temp = array[right];
+            array[right] = array[storeIndex];
+            array[storeIndex] = temp;
             return storeIndex;
         }

         public static IEnumerable<U> FlatMap<T, U>(this IEnumerable<T> source, Func<T, IEnumerable<U>> fn)
         {
+            if (source == null)
+            {
+                throw new ArgumentNullException("source");
+            }
+
             foreach (T enumerable in source)
             {
                 foreach (U element in fn(enumerable))
@@ -176,6 +215,11 @@

         public static T Reduce<T>(this IEnumerable<T> source, Func<T, T, T> fn)
         {
+            if (source == null)
+            {
+                throw new ArgumentNullException("source");
+            }
+
             T folded;
             using (var enumerator = source.GetEnumerator())
             {
@@ -196,6 +240,11 @@

         public static U Fold<T, U>(this IEnumerable<T> source, U init, Func<U, T, U> fn)
         {
+            if (source == null)
+            {
+                throw new ArgumentNullException("source");
+            }
+
             foreach (var element in source)
             {
                 init = fn(init, element);
@@ -205,5 +254,6 @@
         }

         // TODO: test sorting, tid
+        // insetion sort
     }
 }


Moving main content to middle 6 columns

Moving main content to middle 6 columns

--- Views/Layout.cshtml
+++ Views/Layout.cshtml
@@ -85,7 +85,7 @@
             }
             @if (Model.Messages != null || Model.BeforeContent != null || Model.Content != null || Model.AfterContent != null)
             {
-                var mainColClass = (Model.AsideSecond == null) ? "span9" : "span6";
+                var mainColClass = (Model.AsideFirst == null) ? "span6 offset3" : "span6";

                 <div class="@mainColClass">
                     @if (Model.Messages != null)


In this case, combat is not possible.

In this case, combat is not possible.

--- src/Sanderling.ABot/Bot/Bot.cs
+++ src/Sanderling.ABot/Bot/Bot.cs
@@ -122,6 +122,12 @@
 		{
 			var memoryMeasurement = memoryMeasurementAtTime?.Value;

+			var currentManeuverType = memoryMeasurement?.ShipUi?.Indication?.ManeuverType;
+
+			if (ShipManeuverTypeEnum.Warp == currentManeuverType ||
+				ShipManeuverTypeEnum.Jump == currentManeuverType)
+				yield break;
+
 			var listOverviewEntryToAttack =
 				memoryMeasurement?.WindowOverview?.FirstOrDefault()?.ListView?.Entry?.Where(entry => entry?.MainIcon?.Color?.IsRed() ?? false)
 				?.OrderBy(entry => entry?.DistanceMax ?? int.MaxValue)


scanner, continue...

scanner, continue...

--- src/Scanner/GrammarAutomata.cs
+++ src/Scanner/GrammarAutomata.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using System.Xml;

 namespace Elecelf.Hibiki.Scanner
 {
@@ -59,10 +60,66 @@
             var currentBlockState = ParseBlockState.Outline;
             Queue<char?> holdingChars = new Queue<char?>();

+            var automata = new GrammarAutomata();
+            var currentState = automata.StartState;
+            Stack<GrammarState> grammarStates = new Stack<GrammarState>();
+
             uint lookAroundPoint = 1;
             for (; lookAroundPoint <= rawString.Length; lookAroundPoint++)
             {
-
+                // Outline:
+                // On the start state of a automata, or after ending a grammar or a escape block, it's unable to decide a speical state of the automata. It's outline then.
+                // Outline state is a Start State and a Finalize State in a grammar automata.
+                if (currentBlockState == ParseBlockState.Outline)
+                {
+
+                }
+                else if (currentBlockState == ParseBlockState.Escape)
+                {
+
+                }
+                else if (currentBlockState == ParseBlockState.Grammar)
+                {
+
+                }
+                else if (currentBlockState == ParseBlockState.String)
+                {
+
+                }
+
+                // End of char processing.
+                currentChar = lookaroundChar;
+
+                if (lookAroundPoint == rawString.Length)
+                {
+                    // A ETX char used to sign end of a automation. Also close a string state.
+                    lookaroundChar = (char?)3;
+                }
+                else if (lookAroundPoint < rawString.Length)
+                {
+                    lookaroundChar = rawString[(int)lookAroundPoint];
+                }
+                else
+                {
+                    lookaroundChar = null;
+                    break;
+                }
+
+                // Cost off all chars:
+                if (currentChar == null)
+                {
+                    // holding chars are not empty: throw exception.
+                    if (holdingChars.Count > 0)
+                    {
+                        var holdingCharsArray = (from c in holdingChars where c.HasValue && c.Value != (char)3 select c.Value).ToArray();
+                        var holdingCharsString = new string(holdingCharsArray);
+
+                        throw new ParseErrorException("Some chars are not included in a legal state.", "Illegal String", holdingCharsString);
+                    }
+
+                    // or, parse completed.
+                    break;
+                }
             }

             return null;
@@ -153,9 +210,17 @@

     public class ParseErrorException : Exception
     {
+        private readonly Dictionary<string, object> _data = new Dictionary<string, object>();
+        public sealed override IDictionary Data => _data;
+
         public ParseErrorException(string info) : base(info)
         {

         }
+
+        public ParseErrorException(string info, string dataName, object dataValue) : base(info)
+        {
+            Data[dataName] = dataValue;
+        }
     }
 }


デバッグ表示のFPSの更新間隔を2秒に変更

デバッグ表示のFPSの更新間隔を2秒に変更

--- src/Sitrine/Utils/DebugText.cs
+++ src/Sitrine/Utils/DebugText.cs
@@ -42,9 +42,10 @@
         private readonly LinkedList<TextItem> textQueue;

         private double elapsed = 1.0;
+        private double elapsed_fps = 2.0;
         private readonly TextTexture debugTexture;
         private readonly TextTexture debugTextTexture;
-        private double fps_old = 0.0;
+        private double fps_now = 0.0;
         private bool textUpdated = false;
         private DateTime firstQueueTime;

@@ -109,7 +110,6 @@

             this.window = window;
             this.textures = window.Textures;
-            this.fps_old = 60.0;

             this.textQueue = new LinkedList<TextItem>();

@@ -241,14 +241,21 @@
         private void UpdateDebug(double time)
         {
             this.elapsed += time;
+            this.elapsed_fps += time;
+
+            if (this.elapsed_fps >= 2.0)
+            {
+                this.fps_now = this.window.RenderFrequency;
+                this.elapsed_fps = 0.0;
+            }
+
             if (this.elapsed >= 0.25)
             {
-                this.fps_old += (this.window.RenderFrequency - this.fps_old) * 0.2;
                 var storyboards = this.window.Storyboards.ToArray();

                 this.debugTexture.Clear();
                 this.debugTexture.Draw(string.Format("FPS: {0:f1}({1}), T: {2}, L: {3}, U: {4}, S: {5}, A: {6}, L: {7}, P: {8}, M: {9:f2}MB",
-                    this.fps_old,
+                    this.fps_now,
                     (int)Math.Round(1.0 / time),
                     this.textures.Count,
                     DebugText.loadCount - this.loadCountOld,


fix log file on linux

fix log file on linux

--- src/TfsSlackFactory/Program.cs
+++ src/TfsSlackFactory/Program.cs
@@ -20,7 +20,7 @@
             Serilog.Log.Logger = new LoggerConfiguration()
                 .MinimumLevel.Information()
                 .Enrich.FromLogContext()
-                .WriteTo.RollingFile(@"logs\log-{Date}.txt")
+                .WriteTo.RollingFile(Path.Combine("logs", "log-{Date}.txt"))
                 .WriteTo.ColoredConsole()
                 .CreateLogger();


ImageHandler: Refactored.

ImageHandler: Refactored.

git-svn-id: 93f8dae8c9705d66954625438e5916a833f6d1c5@148 90d2b0b2-0e11-ba47-89f1-85e69862abc4

--- src/UncasImageHandler/Form1.cs
+++ src/UncasImageHandler/Form1.cs
@@ -1,4 +1,4 @@
-using System;
+ using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Diagnostics;


Issue #21 - Change the lock from WaitOne(1) to WaitOne(10)

--- src/Unosquare.Swan/Terminal.cs
+++ src/Unosquare.Swan/Terminal.cs
@@ -72,17 +72,16 @@
                 }

                 // Here we start the output task, fire-and-forget
-                DequeueOutputTask = // Here we start the output task, fire-and-forget
                 DequeueOutputTask = new Thread(DequeueOutputAsync)
                 {
-#if !UWP
                     IsBackground = true,
-#endif
                     Name = nameof(DequeueOutputTask),
 #if NET452
                     Priority = ThreadPriority.BelowNormal
 #endif
                 };
+
+                DequeueOutputTask.Start();
             }
         }

@@ -137,7 +136,7 @@
                     if (OutputQueue.Count <= 0)
                     {
                         OutputDone.Set();
-                        tickLock.WaitOne(1);
+                        tickLock.WaitOne(10);
                         continue;
                     }


Remove random comment

Remove random comment

--- src/WebApplication1/Startup.cs
+++ src/WebApplication1/Startup.cs
@@ -18,7 +18,6 @@
     {
         public Startup(IHostingEnvironment env)
         {
-            // comments!!
             var builder = new ConfigurationBuilder()
                 .SetBasePath(env.ContentRootPath)
                 .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)


Fixed correct prefab in RemotePlayer lobby factory

--- src/Booma.Proxy.Client.Unity.Ship/Factory/LobbyRemotePlayerWorldObjectFactory.cs
+++ src/Booma.Proxy.Client.Unity.Ship/Factory/LobbyRemotePlayerWorldObjectFactory.cs
@@ -38,7 +38,7 @@
 			//TODO: Save to assume non-cheaters have sent the required position data.
 			WorldTransform transform = EntityWorldTransformMappable[context.EntityGuid];

-			GameObject player = GameObject.Instantiate(PrefabProvider.LocalPlayerPrefab, transform.Position, transform.Rotation);
+			GameObject player = GameObject.Instantiate(PrefabProvider.RemotePlayerPrefab, transform.Position, transform.Rotation);

 			//This makes it so things can go from GameObject (root) to entity guid.
 			WorldPlayerMap.Add(player, context.EntityGuid);


Correct interpretation was made for parameters

--- src/GfAlgorithms/ComplementaryRepresentationFinder/LinearEquationsBasedFinder.cs
+++ src/GfAlgorithms/ComplementaryRepresentationFinder/LinearEquationsBasedFinder.cs
@@ -96,34 +96,33 @@

         private static IEnumerable<(FieldElement[], FieldElement[], FieldElement[], FieldElement[])> ComputePolyphaseComponentsValues(
             Polynomial polynomial,
-            int maxDegree,
             FieldElement lambda
         )
         {
+            var field = polynomial.Field;
             var (fe, fo) = polynomial.GetPolyphaseComponents();

-            var componentsMaxDegree = (maxDegree + 1) / 2 - 1;
-            var heValues = new FieldElement[componentsMaxDegree + 1];
-            var hoValues = new FieldElement[componentsMaxDegree + 1];
-            var geValues = new FieldElement[componentsMaxDegree + 1];
-            var goValues = new FieldElement[componentsMaxDegree + 1];
+            var valuesCount = (field.Order - 1) / 2;
+            var heValues = new FieldElement[valuesCount];
+            var hoValues = new FieldElement[valuesCount];
+            var geValues = new FieldElement[valuesCount];
+            var goValues = new FieldElement[valuesCount];

-            var field = polynomial.Field;
+
             var argument = field.One();
             var argumentMultiplier = field.CreateElement(field.GetGeneratingElementPower(2));
-
             foreach (var componentsValues in ComputePolyphaseComponentsValues(fe, fo, lambda, argument, argumentMultiplier, 0,
                 heValues, hoValues, geValues, goValues))
                 yield return componentsValues;
         }

-        private Polynomial ReconstructPolynomialByValues(FieldElement[] values)
+        private Polynomial ReconstructPolynomialByValues(FieldElement[] values, int coefficientsCount)
         {
             var field = values[0].Field;
             var argument = field.One();
             var argumentMultiplier = field.CreateElement(field.GetGeneratingElementPower(2));

-            var a = new FieldElement[values.Length, values.Length];
+            var a = new FieldElement[values.Length, coefficientsCount];
             for (var i = 0; i < a.GetLength(0); i++, argument.Multiply(argumentMultiplier))
             {
                 a[i, 0] = field.One();
@@ -152,15 +151,18 @@
             if (lambda != null && polynomial.Field.Equals(lambda.Field) == false)
                 throw new ArgumentException($"{nameof(lambda)} must belong to the field of the polynomial {nameof(polynomial)}");

-            return ComputePolyphaseComponentsValues(polynomial, maxDegree, lambda ?? polynomial.Field.One())
+            var field = polynomial.Field;
+            return ComputePolyphaseComponentsValues(polynomial, lambda ?? field.One())
                 .Select(x =>
                         {
                             var (heValues, hoValues, geValues, goValues) = x;
+                            var evenComponentCoefficientsCount = (field.Order - 1) / 2;
+                            var oddComponentCoefficientsCount = (field.Order - 1) / 2;

-                            var he = ReconstructPolynomialByValues(heValues);
-                            var ho = ReconstructPolynomialByValues(hoValues);
-                            var ge = ReconstructPolynomialByValues(geValues);
-                            var go = ReconstructPolynomialByValues(goValues);
+                            var he = ReconstructPolynomialByValues(heValues, evenComponentCoefficientsCount);
+                            var ho = ReconstructPolynomialByValues(hoValues, oddComponentCoefficientsCount);
+                            var ge = ReconstructPolynomialByValues(geValues, evenComponentCoefficientsCount);
+                            var go = ReconstructPolynomialByValues(goValues, oddComponentCoefficientsCount);

                             return
                             (


39: remove duplicated lib

39: remove duplicated lib

--- src/PixelFarm/PaintLab.RenderTreeComposer/4_FontServices/DrawingGLFontPrinter.cs
+++ src/PixelFarm/PaintLab.RenderTreeComposer/4_FontServices/DrawingGLFontPrinter.cs
@@ -6,9 +6,11 @@
 using PixelFarm.Agg;
 using PixelFarm.Drawing;
 using PixelFarm.Drawing.Fonts;
+//
 using Typography.TextLayout;
 using Typography.TextServices;
 using Typography.OpenFont;
+using Typography.OpenFont.Extensions;

 #if GL_ENABLE

@@ -207,15 +209,16 @@

         //--------
         GLRenderSurface _glsx;
-
-
         GLPainter painter;
         SimpleFontAtlas simpleFontAtlas;
-
         GLBitmap _glBmp;
         RequestFont font;
-
         TextureKind _currentTextureKind;
+
+        int _currentFontRecommendLineSpacing;
+        int _currentFontAscending;
+        int _lineGap;
+        int _lineHeight;

         LayoutFarm.OpenFontTextService _textServices = new LayoutFarm.OpenFontTextService();
         public GLBitmapGlyphTextPrinter(GLPainter painter)
@@ -226,7 +229,7 @@

             this.painter = painter;
             this._glsx = painter.Canvas;
-            _currentTextureKind = TextureKind.StencilGreyScale;
+            _currentTextureKind = TextureKind.Msdf;

             //_currentTextureKind = TextureKind.StencilLcdEffect;
             //_currentTextureKind = TextureKind.Msdf;
@@ -295,6 +298,11 @@
             //scale at request
             float targetTextureScale = _typeface.CalculateScaleToPixelFromPointSize(font.SizeInPoints);
             _finalTextureScale = targetTextureScale / srcTextureScale;
+            _currentFontRecommendLineSpacing = _typeface.CalculateRecommendLineSpacing();
+            _currentFontAscending = _typeface.Ascender;
+            _lineGap = _typeface.LineGap;
+            _lineHeight = _typeface.CalculateLineSpacing(LineSpacingChoice.TypoMetric);
+
         }
         public void Dispose()
         {
@@ -333,15 +341,17 @@

             int j = buffer.Length;
             TextBuffer textBuffer = new TextBuffer(buffer);
-            int outputLineH = 40; //test
+
             GlyphPlanSequence glyphPlanSeq = _textServices.CreateGlyphPlanSeq(textBuffer, startAt, len, font);

             float scale = _typeface.CalculateScaleToPixelFromPointSize(font.SizeInPoints);
+            int recommendLineSpacing = _typeface.CalculateRecommendLineSpacing();
             //--------------------------
             //TODO:
             //if (x,y) is left top
             //we need to adjust y again
-            y -= outputLineH;
+            y -= ((_lineHeight) * scale);
+
             EnsureLoadGLBmp();
             //
             float scaleFromTexture = _finalTextureScale;
@@ -380,6 +390,11 @@
                 g_x = (float)(x + (glyph.ExactX * scale - glyphData.TextureXOffset) * scaleFromTexture); //ideal x
                 g_y = (float)(y + (glyph.ExactY * scale - glyphData.TextureYOffset + srcRect.Height) * scaleFromTexture);

+
+                //for sharp glyph
+                //we adjust g_x,g_y to integer value
+                g_x = (float)Math.Round(g_x);
+                g_y = (float)Math.Round(g_y);

                 switch (textureKind)
                 {


Chnaged the link so users can still enter their company details manually

--- src/SFA.DAS.EAS.Web/Views/SearchOrganisation/SearchForOrganisationResults.cshtml
+++ src/SFA.DAS.EAS.Web/Views/SearchOrganisation/SearchForOrganisationResults.cshtml
@@ -94,7 +94,7 @@

Can't find your organisation?

Check the spelling and search again.

-
You can also enter your details manually.

+
You can also enter your details manually.

                 }

@@ -107,7 +107,7 @@

Can't find your organisation?

Check the spelling and search again.

-
You can also enter your details manually.

+
You can also enter your details manually.

             }


Add comment

Add comment

--- src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexParser.cs
+++ src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/RegexParser.cs
@@ -1139,6 +1139,32 @@

         private RegexBaseCharacterClassNode ParseCharacterClass()
         {
+            // Note: ScanCharClass is one of the strangest function in the .net regex parser. Code
+            // for it is here:
+            // https://github.com/dotnet/corefx/blob/6ae0da1563e6e701bac61012c62ede8f8737f065/src/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexParser.cs#L498
+            //
+            // It has certain behaviors that were probably not intentional, but which we try to
+            // replicate.  Specifically, it looks like it was *intended* to just read components
+            // like simple characters ('a'), char-class-escape ('\s' and the like), ranges
+            // ('component-component'), and subtractions ('-[charclass]').
+            //
+            // And, it *looks* like it intended that if it ran into a range, it would check that the
+            // components on the left and right of the '-' made sense (i.e. you could have 'a-b' but
+            // not 'b-a').
+            //
+            // *However*, the way it is actually written, it does not have that behavior.  Instead,
+            // what it ends up doing is subtly different.  Specifically, in this switch:
+            // https://github.com/dotnet/corefx/blob/6ae0da1563e6e701bac61012c62ede8f8737f065/src/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexParser.cs#L531
+            //
+            // In this switch, if it encounters a '\-' it immediately 'continues', effectively
+            // ignoring that character on the right side of a character range.  So, if you had
+            // ```[#-\-b]```, then this *should* be treated as the character class containing
+            // the range of character from '#' to '-', unioned with the character 'b'.  However,
+            // .net will interpret this as the character class containing the range of characters
+            // from '#' to 'b'.  We follow .Net here to keep our errors in sync with them.
+            //
+            // See the comment about this in ParseRightSideOfCharacterClassRange
+
             var openBracketToken = _currentToken;
             Debug.Assert(openBracketToken.Kind == RegexKind.OpenBracketToken);
             var caretToken = CreateMissingToken(RegexKind.CaretToken);


Refactor `UITestFixture`

Refactor `UITestFixture`

--- test/Atata.WebDriverExtras.Tests/UITestFixture.cs
+++ test/Atata.WebDriverExtras.Tests/UITestFixture.cs
@@ -1,6 +1,6 @@
 using NUnit.Framework;
+using OpenQA.Selenium;
 using OpenQA.Selenium.Chrome;
-using OpenQA.Selenium.Remote;

 namespace Atata.WebDriverExtras.Tests
 {
@@ -9,7 +9,7 @@
     {
         public const string BaseUrl = "http://localhost:57440/";

-        protected RemoteWebDriver Driver { get; private set; }
+        protected IWebDriver Driver { get; private set; }

         [SetUp]
         public virtual void SetUp()
@@ -24,7 +24,7 @@
             Driver?.Dispose();
         }

-        protected RemoteWebDriver GoTo(string relativeUrl)
+        protected IWebDriver GoTo(string relativeUrl)
         {
             Driver.Navigate().GoToUrl(BaseUrl + relativeUrl);
             return Driver;


Making EventHubTrigger test more robust

Making EventHubTrigger test more robust

--- test/WebJobs.Script.Tests/SamplesEndToEndTests.cs
+++ test/WebJobs.Script.Tests/SamplesEndToEndTests.cs
@@ -58,7 +58,17 @@
             }

             string connectionString = Environment.GetEnvironmentVariable("AzureWebJobsEventHubSender");
-            string eventHubName = Environment.GetEnvironmentVariable("AzureWebJobsEventHubPath");
+            ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(connectionString);
+            string eventHubName;
+            if (!string.IsNullOrWhiteSpace(builder.EntityPath))
+            {
+                eventHubName = builder.EntityPath;
+            }
+            else
+            {
+                eventHubName = Environment.GetEnvironmentVariable("AzureWebJobsEventHubPath");
+            }
+
             var eventHubClient = EventHubClient.CreateFromConnectionString(connectionString, eventHubName);
             await eventHubClient.SendBatchAsync(events);


DanielWagnerHall: Actually launch the test server

git-svn-id: aa1aa1384423cb28c2b1e29129bb3a91de1d9196@10930 07704840-8298-11de-bf8c-fd130f914ac9

--- support/test/csharp/webdriver-support-test/PageFactory/PageFactoryBrowserTest.cs
+++ support/test/csharp/webdriver-support-test/PageFactory/PageFactoryBrowserTest.cs
@@ -1,7 +1,26 @@
 using NUnit.Framework;
+using OpenQA.Selenium.Environment;

 namespace OpenQA.Selenium.Support.PageFactory
 {
+	//TODO: Move this to a standalone class when more tests rely on the server being up
+	[SetUpFixture]
+	public class SetUpClass
+	{
+		[SetUp]
+		public void RunBeforeAnyTest()
+		{
+			EnvironmentManager.Instance.WebServer.Start();
+		}
+
+		[TearDown]
+		public void RunAfterAnyTests()
+		{
+			EnvironmentManager.Instance.CloseCurrentDriver();
+			EnvironmentManager.Instance.WebServer.Stop();
+		}
+	}
+
     [TestFixture]
     public class PageFactoryBrowserTest : DriverTestFixture
     {