Release 1.6.2

Closes #91

Core/Handling/ContextMenuBase.cs

@@ -3,6 +3,7 @@ using System;
 using System.IO;
 using System.Windows.Forms;
 using TweetDck.Core.Bridge;
+using TweetDck.Core.Controls;
 using TweetDck.Core.Utils;
 
 namespace TweetDck.Core.Handling{
@@ -21,6 +22,12 @@ namespace TweetDck.Core.Handling{
         }
         #endif
 
+        private readonly Form form;
+
+        protected ContextMenuBase(Form form){
+            this.form = form;
+        }
+
         public virtual void OnBeforeContextMenu(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, IMenuModel model){
             if (parameters.TypeFlags.HasFlag(ContextMenuType.Link) && !parameters.UnfilteredLinkUrl.EndsWith("tweetdeck.twitter.com/#", StringComparison.Ordinal)){
                 model.AddItem((CefMenuCommand)MenuOpenLinkUrl, "Open link in browser");
@@ -43,7 +50,7 @@ namespace TweetDck.Core.Handling{
                     break;
 
                 case MenuCopyLinkUrl:
-                    Clipboard.SetText(string.IsNullOrEmpty(TweetDeckBridge.LastRightClickedLink) ? parameters.UnfilteredLinkUrl : TweetDeckBridge.LastRightClickedLink, TextDataFormat.UnicodeText);
+                    SetClipboardText(string.IsNullOrEmpty(TweetDeckBridge.LastRightClickedLink) ? parameters.UnfilteredLinkUrl : TweetDeckBridge.LastRightClickedLink);
                     break;
 
                 case MenuOpenImage:
@@ -74,7 +81,7 @@ namespace TweetDck.Core.Handling{
                     break;
 
                 case MenuCopyImageUrl:
-                    Clipboard.SetText(parameters.SourceUrl, TextDataFormat.UnicodeText);
+                    SetClipboardText(parameters.SourceUrl);
                     break;
 
                 #if DEBUG
@@ -93,6 +100,10 @@ namespace TweetDck.Core.Handling{
             return false;
         }
 
+        protected void SetClipboardText(string text){
+            form.InvokeSafe(() => WindowsUtils.SetClipboard(text, TextDataFormat.UnicodeText));
+        }
+
         protected static void RemoveSeparatorIfLast(IMenuModel model){
             if (model.Count > 0 && model.GetTypeAt(model.Count-1) == MenuItemType.Separator){
                 model.RemoveAt(model.Count-1);

Core/Handling/ContextMenuBrowser.cs

@@ -1,5 +1,4 @@
 using CefSharp;
-using System.Windows.Forms;
 using TweetDck.Core.Bridge;
 using TweetDck.Core.Controls;
 using TweetDck.Core.Utils;
@@ -23,7 +22,7 @@ namespace TweetDck.Core.Handling{
         private string lastHighlightedTweet;
         private string lastHighlightedQuotedTweet;
 
-        public ContextMenuBrowser(FormBrowser form){
+        public ContextMenuBrowser(FormBrowser form) : base(form){
             this.form = form;
         }
 
@@ -114,7 +113,7 @@ namespace TweetDck.Core.Handling{
                     return true;
 
                 case MenuCopyTweetUrl:
-                    Clipboard.SetText(lastHighlightedTweet, TextDataFormat.UnicodeText);
+                    SetClipboardText(lastHighlightedTweet);
                     return true;
 
                 case MenuScreenshotTweet:
@@ -126,7 +125,7 @@ namespace TweetDck.Core.Handling{
                     return true;
 
                 case MenuCopyQuotedTweetUrl:
-                    Clipboard.SetText(lastHighlightedQuotedTweet, TextDataFormat.UnicodeText);
+                    SetClipboardText(lastHighlightedQuotedTweet);
                     return true;
             }
 

Core/Handling/ContextMenuNotification.cs

@@ -1,6 +1,6 @@
-using System.Windows.Forms;
-using CefSharp;
+using CefSharp;
 using TweetDck.Core.Controls;
+using TweetDck.Core.Utils;
 
 namespace TweetDck.Core.Handling{
     class ContextMenuNotification : ContextMenuBase{
@@ -12,7 +12,7 @@ namespace TweetDck.Core.Handling{
         private readonly FormNotification form;
         private readonly bool enableCustomMenu;
 
-        public ContextMenuNotification(FormNotification form, bool enableCustomMenu){
+        public ContextMenuNotification(FormNotification form, bool enableCustomMenu) : base(form){
             this.form = form;
             this.enableCustomMenu = enableCustomMenu;
         }
@@ -62,11 +62,11 @@ namespace TweetDck.Core.Handling{
                     return true;
 
                 case MenuCopyTweetUrl:
-                    Clipboard.SetText(form.CurrentUrl, TextDataFormat.UnicodeText);
+                    SetClipboardText(form.CurrentUrl);
                     return true;
 
                 case MenuCopyQuotedTweetUrl:
-                    Clipboard.SetText(form.CurrentQuotedTweetUrl, TextDataFormat.UnicodeText);
+                    SetClipboardText(form.CurrentQuotedTweetUrl);
                     return true;
             }
 

Core/Other/Settings/Export/CombinedFileStream.cs

@@ -121,8 +121,11 @@ namespace TweetDck.Core.Other.Settings.Export{
 
             public void WriteToFile(string path, bool createDirectory){
                 if (createDirectory){
-                    // ReSharper disable once AssignNullToNotNullAttribute
-                    Directory.CreateDirectory(Path.GetDirectoryName(path));
+                    string dir = Path.GetDirectoryName(path);
+
+                    if (!string.IsNullOrEmpty(dir)){
+                        Directory.CreateDirectory(dir);
+                    }
                 }
 
                 File.WriteAllBytes(path, contents);

Core/Utils/CommandLineArgs.cs

@@ -105,7 +105,7 @@ namespace TweetDck.Core.Utils{
                 build.Append(kvp.Key).Append(" \"").Append(kvp.Value).Append("\" ");
             }
 
-            return build.Remove(build.Length-1, 1).ToString();
+            return build.Length == 0 ? string.Empty : build.Remove(build.Length-1, 1).ToString();
         }
     }
 }

Core/Utils/NativeMethods.cs

@@ -24,13 +24,26 @@ namespace TweetDck.Core.Utils{
             Left, Right
         }
 
+        private struct LASTINPUTINFO{
+            public static readonly uint Size = (uint)Marshal.SizeOf(typeof(LASTINPUTINFO));
+
+            // ReSharper disable once NotAccessedField.Local
+            public uint cbSize;
+            #pragma warning disable 649
+            public uint dwTime;
+            #pragma warning restore 649
+        }
+
         public delegate IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam);
 
         [DllImport("user32.dll", EntryPoint = "SetWindowPos")]
-        public static extern bool SetWindowPos(int hWnd, int hWndOrder, int x, int y, int width, int height, uint flags);
+        private static extern bool SetWindowPos(int hWnd, int hWndOrder, int x, int y, int width, int height, uint flags);
 
         [DllImport("user32.dll")]
-        public static extern void mouse_event(int dwFlags, int dx, int dy, int cButtons, int dwExtraInfo);
+        private static extern void mouse_event(int dwFlags, int dx, int dy, int cButtons, int dwExtraInfo);
+
+        [DllImport("user32.dll")]
+        private static extern bool GetLastInputInfo(ref LASTINPUTINFO info);
 
         [DllImport("user32.dll")]
         public static extern IntPtr SendMessage(IntPtr hWnd, uint msg, int wParam, IntPtr lParam);
@@ -75,5 +88,23 @@ namespace TweetDck.Core.Utils{
             mouse_event(flagHold, Cursor.Position.X, Cursor.Position.Y, 0, 0);
             mouse_event(flagRelease, Cursor.Position.X, Cursor.Position.Y, 0, 0);
         }
+
+        public static int GetIdleSeconds(){
+            LASTINPUTINFO info = new LASTINPUTINFO();
+            info.cbSize = LASTINPUTINFO.Size;
+
+            if (!GetLastInputInfo(ref info)){
+                return 0;
+            }
+
+            uint ticks;
+
+            unchecked{
+                ticks = (uint)Environment.TickCount;
+            }
+
+            int seconds = (int)Math.Floor(TimeSpan.FromMilliseconds(ticks-info.dwTime).TotalSeconds);
+            return Math.Max(0, seconds); // ignore rollover after several weeks of uptime
+        }
     }
 }

Core/Utils/WindowsUtils.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.IO;
+using System.Runtime.InteropServices;
 using System.Text.RegularExpressions;
 using System.Windows.Forms;
 
@@ -49,13 +50,36 @@ namespace TweetDck.Core.Utils{
                 return;
             }
 
-            string original = Clipboard.GetText(TextDataFormat.Html);
-            string updated = RegexStripHtmlStyles.Replace(original, string.Empty);
+            string originalText = Clipboard.GetText(TextDataFormat.UnicodeText);
+            string originalHtml = Clipboard.GetText(TextDataFormat.Html);
 
-            int removed = original.Length-updated.Length;
-            updated = RegexOffsetClipboardHtml.Replace(updated, match => (int.Parse(match.Value)-removed).ToString().PadLeft(match.Value.Length, '0'));
+            string updatedHtml = RegexStripHtmlStyles.Replace(originalHtml, string.Empty);
 
-            Clipboard.SetText(updated, TextDataFormat.Html);
+            int removed = originalHtml.Length-updatedHtml.Length;
+            updatedHtml = RegexOffsetClipboardHtml.Replace(updatedHtml, match => (int.Parse(match.Value)-removed).ToString().PadLeft(match.Value.Length, '0'));
+
+            DataObject obj = new DataObject();
+            obj.SetText(originalText, TextDataFormat.UnicodeText);
+            obj.SetText(updatedHtml, TextDataFormat.Html);
+            SetClipboardData(obj);
+        }
+
+        public static void SetClipboard(string text, TextDataFormat format){
+            if (string.IsNullOrEmpty(text)){
+                return;
+            }
+
+            DataObject obj = new DataObject();
+            obj.SetText(text, format);
+            SetClipboardData(obj);
+        }
+
+        private static void SetClipboardData(DataObject obj){
+            try{
+                Clipboard.SetDataObject(obj);
+            }catch(ExternalException e){
+                Program.Reporter.HandleException("Clipboard Error", Program.BrandName+" could not access the clipboard as it is currently used by another process.", true, e);
+            }
         }
     }
 }

Program.cs

@@ -21,8 +21,8 @@ namespace TweetDck{
         public const string BrandName = "TweetDuck";
         public const string Website = "https://tweetduck.chylex.com";
 
-        public const string VersionTag = "1.6.1";
-        public const string VersionFull = "1.6.1.0";
+        public const string VersionTag = "1.6.2";
+        public const string VersionFull = "1.6.2.0";
 
         public static readonly Version Version = new Version(VersionTag);
 

Properties/AssemblyInfo.cs

@@ -37,3 +37,7 @@ using TweetDck;
 [assembly: AssemblyFileVersion(Program.VersionFull)]
 
 [assembly: NeutralResourcesLanguageAttribute("en")]
+
+#if DEBUG
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("UnitTests")]
+#endif

TweetDck.sln

@@ -1,21 +1,31 @@
-
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 2013
 VisualStudioVersion = 12.0.40629.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TweetDck", "TweetDck.csproj", "{2389A7CD-E0D3-4706-8294-092929A33A2D}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitTests", "tests\UnitTests.csproj", "{A958FA7A-4A2C-42A7-BFA0-159343483F4E}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
 		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
 		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{2389A7CD-E0D3-4706-8294-092929A33A2D}.Debug|Any CPU.ActiveCfg = Debug|x86
 		{2389A7CD-E0D3-4706-8294-092929A33A2D}.Debug|x86.ActiveCfg = Debug|x86
 		{2389A7CD-E0D3-4706-8294-092929A33A2D}.Debug|x86.Build.0 = Debug|x86
 		{2389A7CD-E0D3-4706-8294-092929A33A2D}.Debug|x86.Deploy.0 = Debug|x86
+		{2389A7CD-E0D3-4706-8294-092929A33A2D}.Release|Any CPU.ActiveCfg = Release|x86
 		{2389A7CD-E0D3-4706-8294-092929A33A2D}.Release|x86.ActiveCfg = Release|x86
 		{2389A7CD-E0D3-4706-8294-092929A33A2D}.Release|x86.Build.0 = Release|x86
+		{A958FA7A-4A2C-42A7-BFA0-159343483F4E}.Debug|Any CPU.ActiveCfg = Debug|x86
+		{A958FA7A-4A2C-42A7-BFA0-159343483F4E}.Debug|x86.ActiveCfg = Debug|x86
+		{A958FA7A-4A2C-42A7-BFA0-159343483F4E}.Debug|x86.Build.0 = Debug|x86
+		{A958FA7A-4A2C-42A7-BFA0-159343483F4E}.Release|Any CPU.ActiveCfg = Release|x86
+		{A958FA7A-4A2C-42A7-BFA0-159343483F4E}.Release|x86.ActiveCfg = Release|x86
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

TweetDck.sln.DotSettings

@@ -0,0 +1,2 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/FilterSettingsManager/CoverageFilterXml/@EntryValue">&lt;data&gt;&lt;IncludeFilters /&gt;&lt;ExcludeFilters&gt;&lt;Filter ModuleMask="UnitTests" ModuleVersionMask="*" ClassMask="*" FunctionMask="*" IsEnabled="True" /&gt;&lt;/ExcludeFilters&gt;&lt;/data&gt;</s:String></wpf:ResourceDictionary>

Updates/UpdateHandler.cs

@@ -82,7 +82,7 @@ namespace TweetDck.Updates{
 
             public bool IsSystemSupported{
                 get{
-                    return Environment.OSVersion.Version >= new Version("6.1"); // 6.1 NT version = Windows 7
+                    return true; // Environment.OSVersion.Version >= new Version("6.1"); // 6.1 NT version = Windows 7
                 }
             }
 

tests/Core/Settings/TestCombinedFileStream.cs

@@ -0,0 +1,143 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.IO;
+using TweetDck.Core.Other.Settings.Export;
+
+namespace UnitTests.Core.Settings{
+    [TestClass]
+    public class TestCombinedFileStream{
+        [TestMethod]
+        public void TestNoFiles(){
+            using(CombinedFileStream cfs = new CombinedFileStream(TestUtils.WriteFile("cfs_empty"))){
+                cfs.Flush();
+            }
+
+            Assert.IsTrue(File.Exists("cfs_empty"));
+
+            using(CombinedFileStream cfs = new CombinedFileStream(TestUtils.ReadFile("cfs_empty"))){
+                Assert.IsNull(cfs.ReadFile());
+            }
+
+            using(CombinedFileStream cfs = new CombinedFileStream(TestUtils.ReadFile("cfs_empty"))){
+                Assert.IsNull(cfs.SkipFile());
+            }
+        }
+
+        [TestMethod]
+        public void TestEmptyFiles(){
+            TestUtils.WriteText("cfs_input_empty_1", string.Empty);
+            TestUtils.WriteText("cfs_input_empty_2", string.Empty);
+
+            using(CombinedFileStream cfs = new CombinedFileStream(TestUtils.WriteFile("cfs_blank_files"))){
+                cfs.WriteFile("id1", "cfs_input_empty_1");
+                cfs.WriteFile("id2", "cfs_input_empty_2");
+                cfs.WriteFile("id2_clone", "cfs_input_empty_2");
+                cfs.Flush();
+            }
+
+            Assert.IsTrue(File.Exists("cfs_blank_files"));
+
+            using(CombinedFileStream cfs = new CombinedFileStream(TestUtils.ReadFile("cfs_blank_files"))){
+                CombinedFileStream.Entry entry1 = cfs.ReadFile();
+                string entry2key = cfs.SkipFile();
+                CombinedFileStream.Entry entry3 = cfs.ReadFile();
+
+                Assert.IsNull(cfs.ReadFile());
+                Assert.IsNull(cfs.SkipFile());
+
+                Assert.AreEqual("id1", entry1.KeyName);
+                Assert.AreEqual("id1", entry1.Identifier);
+                CollectionAssert.AreEqual(new string[0], entry1.KeyValue);
+
+                Assert.AreEqual("id2", entry2key);
+
+                Assert.AreEqual("id2_clone", entry3.KeyName);
+                Assert.AreEqual("id2_clone", entry3.Identifier);
+                CollectionAssert.AreEqual(new string[0], entry3.KeyValue);
+
+                entry1.WriteToFile("cfs_blank_file_1");
+                entry3.WriteToFile("cfs_blank_file_2");
+                TestUtils.DeleteFileOnExit("cfs_blank_file_1");
+                TestUtils.DeleteFileOnExit("cfs_blank_file_2");
+            }
+
+            Assert.IsTrue(File.Exists("cfs_blank_file_1"));
+            Assert.IsTrue(File.Exists("cfs_blank_file_2"));
+            Assert.AreEqual(string.Empty, TestUtils.ReadText("cfs_blank_file_1"));
+            Assert.AreEqual(string.Empty, TestUtils.ReadText("cfs_blank_file_2"));
+        }
+
+        [TestMethod]
+        public void TestTextFilesAndComplexKeys(){
+            TestUtils.WriteText("cfs_input_text_1", "Hello World!"+Environment.NewLine);
+
+            using(CombinedFileStream cfs = new CombinedFileStream(TestUtils.WriteFile("cfs_text_files"))){
+                cfs.WriteFile(new string[]{ "key1", "a", "bb", "ccc", "dddd" }, "cfs_input_text_1");
+                cfs.WriteFile(new string[]{ "key2", "a", "bb", "ccc", "dddd" }, "cfs_input_text_1");
+                cfs.Flush();
+            }
+
+            Assert.IsTrue(File.Exists("cfs_text_files"));
+
+            using(CombinedFileStream cfs = new CombinedFileStream(TestUtils.ReadFile("cfs_text_files"))){
+                CombinedFileStream.Entry entry = cfs.ReadFile();
+
+                Assert.AreEqual("key2", cfs.SkipFile());
+                Assert.IsNull(cfs.ReadFile());
+                Assert.IsNull(cfs.SkipFile());
+
+                Assert.AreEqual("key1|a|bb|ccc|dddd", entry.Identifier);
+                Assert.AreEqual("key1", entry.KeyName);
+                CollectionAssert.AreEqual(new string[]{ "a", "bb", "ccc", "dddd" }, entry.KeyValue);
+
+                entry.WriteToFile("cfs_text_file_1");
+                TestUtils.DeleteFileOnExit("cfs_text_file_1");
+            }
+
+            Assert.IsTrue(File.Exists("cfs_text_file_1"));
+            Assert.AreEqual("Hello World!"+Environment.NewLine, TestUtils.ReadText("cfs_text_file_1"));
+        }
+
+        [TestMethod]
+        public void TestEntryWriteWithDirectory(){
+            if (Directory.Exists("cfs_directory")){
+                Directory.Delete("cfs_directory", true);
+            }
+
+            TestUtils.WriteText("cfs_input_dir_1", "test");
+
+            using(CombinedFileStream cfs = new CombinedFileStream(TestUtils.WriteFile("cfs_dir_test"))){
+                cfs.WriteFile("key1", "cfs_input_dir_1");
+                cfs.WriteFile("key2", "cfs_input_dir_1");
+                cfs.WriteFile("key3", "cfs_input_dir_1");
+                cfs.WriteFile("key4", "cfs_input_dir_1");
+                cfs.Flush();
+            }
+
+            Assert.IsTrue(File.Exists("cfs_dir_test"));
+
+            using(CombinedFileStream cfs = new CombinedFileStream(TestUtils.ReadFile("cfs_dir_test"))){
+                try{
+                    cfs.ReadFile().WriteToFile("cfs_directory/cfs_dir_test_file", false);
+                    Assert.Fail("WriteToFile did not trigger an exception.");
+                }catch(DirectoryNotFoundException){}
+
+                cfs.ReadFile().WriteToFile("cfs_directory/cfs_dir_test_file", true);
+                cfs.ReadFile().WriteToFile("cfs_dir_test_file", true);
+                cfs.ReadFile().WriteToFile("cfs_dir_test_file.txt", true);
+                TestUtils.DeleteFileOnExit("cfs_dir_test_file");
+                TestUtils.DeleteFileOnExit("cfs_dir_test_file.txt");
+            }
+
+            Assert.IsTrue(Directory.Exists("cfs_directory"));
+            Assert.IsTrue(File.Exists("cfs_directory/cfs_dir_test_file"));
+            Assert.IsTrue(File.Exists("cfs_dir_test_file"));
+            Assert.IsTrue(File.Exists("cfs_dir_test_file.txt"));
+            Assert.AreEqual("test", TestUtils.ReadText("cfs_directory/cfs_dir_test_file"));
+            Assert.AreEqual("test", TestUtils.ReadText("cfs_dir_test_file"));
+            Assert.AreEqual("test", TestUtils.ReadText("cfs_dir_test_file.txt"));
+
+            Directory.Delete("cfs_directory", true);
+        }
+    }
+}

tests/Core/Utils/TestBrowserUtils.cs

@@ -0,0 +1,19 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using TweetDck.Core.Utils;
+
+namespace UnitTests.Core.Utils{
+    [TestClass]
+    public class TestBrowserUtils{
+        [TestMethod]
+        public void TestGetFileNameFromUrl(){
+            Assert.AreEqual("index.html", BrowserUtils.GetFileNameFromUrl("http://test.com/index.html"));
+            Assert.AreEqual("index.html", BrowserUtils.GetFileNameFromUrl("http://test.com/index.html?"));
+            Assert.AreEqual("index.html", BrowserUtils.GetFileNameFromUrl("http://test.com/index.html?param1=abc&param2=false"));
+            
+            Assert.AreEqual("index", BrowserUtils.GetFileNameFromUrl("http://test.com/index"));
+            Assert.AreEqual("index.", BrowserUtils.GetFileNameFromUrl("http://test.com/index."));
+
+            Assert.IsNull(BrowserUtils.GetFileNameFromUrl("http://test.com/"));
+        }
+    }
+}

tests/Core/Utils/TestCommandLineArgs.cs

@@ -0,0 +1,157 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Generic;
+using TweetDck.Core.Utils;
+
+namespace UnitTests.Core.Utils{
+    [TestClass]
+    public class TestCommandLineArgs{
+        [TestMethod]
+        public void TestEmpty(){
+            CommandLineArgs args = new CommandLineArgs();
+
+            Assert.AreEqual(0, args.Count);
+            Assert.AreEqual(string.Empty, args.ToString());
+
+            Assert.IsFalse(args.HasFlag("x"));
+            Assert.IsFalse(args.HasValue("x"));
+            Assert.AreEqual("default", args.GetValue("x", "default"));
+
+            args.RemoveFlag("x");
+            args.RemoveValue("x");
+
+            var dict = new Dictionary<string, string>();
+            args.ToDictionary(dict);
+            Assert.AreEqual(0, dict.Count);
+        }
+
+        [TestMethod]
+        public void TestFlags(){
+            CommandLineArgs args = new CommandLineArgs();
+
+            args.AddFlag("my_test_flag_1");
+            args.AddFlag("my_test_flag_2");
+            args.AddFlag("aAaAa");
+
+            Assert.IsFalse(args.HasValue("aAaAa"));
+
+            Assert.AreEqual(3, args.Count);
+            Assert.IsTrue(args.HasFlag("my_test_flag_1"));
+            Assert.IsTrue(args.HasFlag("my_test_flag_2"));
+            Assert.IsTrue(args.HasFlag("aaaaa"));
+            Assert.IsTrue(args.HasFlag("AAAAA"));
+            Assert.AreEqual("my_test_flag_1 my_test_flag_2 aaaaa", args.ToString());
+
+            args.RemoveFlag("Aaaaa");
+
+            Assert.AreEqual(2, args.Count);
+            Assert.IsTrue(args.HasFlag("my_test_flag_1"));
+            Assert.IsTrue(args.HasFlag("my_test_flag_2"));
+            Assert.IsFalse(args.HasFlag("aaaaa"));
+            Assert.AreEqual("my_test_flag_1 my_test_flag_2", args.ToString());
+        }
+
+        [TestMethod]
+        public void TestValues(){
+            CommandLineArgs args = new CommandLineArgs();
+
+            args.SetValue("test_value", "My Test Value");
+            args.SetValue("aAaAa", "aaaaa");
+
+            Assert.IsFalse(args.HasFlag("aAaAa"));
+
+            Assert.AreEqual(2, args.Count);
+            Assert.IsTrue(args.HasValue("test_value"));
+            Assert.IsTrue(args.HasValue("aaaaa"));
+            Assert.IsTrue(args.HasValue("AAAAA"));
+            Assert.AreEqual("My Test Value", args.GetValue("test_value", string.Empty));
+            Assert.AreEqual("aaaaa", args.GetValue("aaaaa", string.Empty));
+            Assert.AreEqual("test_value \"My Test Value\" aaaaa \"aaaaa\"", args.ToString());
+
+            args.RemoveValue("Aaaaa");
+
+            Assert.AreEqual(1, args.Count);
+            Assert.IsTrue(args.HasValue("test_value"));
+            Assert.IsFalse(args.HasValue("aaaaa"));
+            Assert.AreEqual("test_value \"My Test Value\"", args.ToString());
+        }
+
+        [TestMethod]
+        public void TestFlagAndValueMix(){
+            CommandLineArgs args = new CommandLineArgs();
+            
+            args.AddFlag("my_test_flag_1");
+            args.AddFlag("my_test_flag_2");
+            args.AddFlag("aAaAa");
+
+            args.SetValue("test_value", "My Test Value");
+            args.SetValue("aAaAa", "aaaaa");
+
+            Assert.AreEqual(5, args.Count);
+            Assert.IsTrue(args.HasFlag("aaaaa"));
+            Assert.IsTrue(args.HasValue("aaaaa"));
+            Assert.AreEqual("my_test_flag_1 my_test_flag_2 aaaaa test_value \"My Test Value\" aaaaa \"aaaaa\"", args.ToString());
+
+            var dict = new Dictionary<string, string>();
+            args.ToDictionary(dict); // loses 'aaaaa' flag
+
+            Assert.AreEqual(4, dict.Count);
+            Assert.AreEqual("1", dict["my_test_flag_1"]);
+            Assert.AreEqual("1", dict["my_test_flag_2"]);
+            Assert.AreEqual("My Test Value", dict["test_value"]);
+            Assert.AreEqual("aaaaa", dict["aaaaa"]);
+        }
+
+        [TestMethod]
+        public void TestClone(){
+            CommandLineArgs args = new CommandLineArgs();
+            
+            args.AddFlag("my_test_flag_1");
+            args.AddFlag("my_test_flag_2");
+            args.AddFlag("aAaAa");
+
+            args.SetValue("test_value", "My Test Value");
+            args.SetValue("aAaAa", "aaaaa");
+
+            CommandLineArgs clone = args.Clone();
+            args.RemoveFlag("aaaaa");
+            args.RemoveValue("aaaaa");
+            clone.RemoveFlag("my_test_flag_1");
+            clone.RemoveFlag("my_test_flag_2");
+            clone.RemoveValue("test_value");
+
+            Assert.AreEqual(3, args.Count);
+            Assert.AreEqual(2, clone.Count);
+
+            Assert.AreEqual("my_test_flag_1 my_test_flag_2 test_value \"My Test Value\"", args.ToString());
+            Assert.AreEqual("aaaaa aaaaa \"aaaaa\"", clone.ToString());
+        }
+
+        [TestMethod]
+        public void TestEmptyStringArray(){
+            CommandLineArgs args;
+            
+            args = CommandLineArgs.FromStringArray('-', new string[0]);
+            Assert.AreEqual(0, args.Count);
+
+            args = CommandLineArgs.FromStringArray('-', new string[]{ "", "+fail", "@nope" });
+            Assert.AreEqual(0, args.Count);
+        }
+
+        [TestMethod]
+        public void TestValidStringArray(){
+            CommandLineArgs args;
+            
+            args = CommandLineArgs.FromStringArray('-', new string[]{ "-flag1", "-flag2", "-FLAG3" });
+            Assert.AreEqual(3, args.Count);
+            Assert.IsTrue(args.HasFlag("-flag1"));
+            Assert.IsTrue(args.HasFlag("-flag2"));
+            Assert.IsTrue(args.HasFlag("-flag3"));
+
+            args = CommandLineArgs.FromStringArray('-', new string[]{ "-flag", "-value", "Here is some text!" });
+            Assert.AreEqual(2, args.Count);
+            Assert.IsTrue(args.HasFlag("-flag"));
+            Assert.IsTrue(args.HasValue("-value"));
+            Assert.AreEqual("Here is some text!", args.GetValue("-value", string.Empty));
+        }
+    }
+}

tests/Core/Utils/TestCommandLineArgsParser.cs

@@ -0,0 +1,32 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using TweetDck.Core.Utils;
+
+namespace UnitTests.Core.Utils{
+    [TestClass]
+    public class TestCommandLineArgsParser{
+        [TestMethod]
+        public void TestEmptyString(){
+            Assert.AreEqual(0, CommandLineArgsParser.ReadCefArguments("").Count);
+            Assert.AreEqual(0, CommandLineArgsParser.ReadCefArguments("     ").Count);
+        }
+
+        [TestMethod]
+        public void TestValidString(){
+            CommandLineArgs args = CommandLineArgsParser.ReadCefArguments("--aaa --bbb --first-value=123 --SECOND-VALUE=\"a b c d e\" --ccc");
+            // cef has no flags, flag arguments have a value of 1
+            // the processing removes all dashes in front of each key
+
+            Assert.AreEqual(5, args.Count);
+            Assert.IsTrue(args.HasValue("aaa"));
+            Assert.IsTrue(args.HasValue("bbb"));
+            Assert.IsTrue(args.HasValue("ccc"));
+            Assert.IsTrue(args.HasValue("first-value"));
+            Assert.IsTrue(args.HasValue("second-value"));
+            Assert.AreEqual("1", args.GetValue("aaa", string.Empty));
+            Assert.AreEqual("1", args.GetValue("bbb", string.Empty));
+            Assert.AreEqual("1", args.GetValue("ccc", string.Empty));
+            Assert.AreEqual("123", args.GetValue("first-value", string.Empty));
+            Assert.AreEqual("a b c d e", args.GetValue("second-value", string.Empty));
+        }
+    }
+}

tests/Properties/AssemblyInfo.cs

@@ -0,0 +1,35 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("UnitTests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("UnitTests")]
+[assembly: AssemblyCopyright("")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("99036b78-aad6-4a76-8bf3-40c77eca2464")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// 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")]

tests/TestUtils.cs

@@ -0,0 +1,65 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Text;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace UnitTests{
+    public static class TestUtils{
+        private static readonly HashSet<string> CreatedFiles = new HashSet<string>();
+
+        public static void WriteText(string file, string text){
+            DeleteFileOnExit(file);
+            File.WriteAllText(file, text, Encoding.UTF8);
+        }
+
+        public static void WriteLines(string file, IEnumerable<string> lines){
+            DeleteFileOnExit(file);
+            File.WriteAllLines(file, lines, Encoding.UTF8);
+        }
+
+        public static FileStream WriteFile(string file){
+            DeleteFileOnExit(file);
+            return new FileStream(file, FileMode.Create, FileAccess.Write, FileShare.None);
+        }
+
+        public static string ReadText(string file){
+            try{
+                return File.ReadAllText(file, Encoding.UTF8);
+            }catch(Exception){
+                return string.Empty;
+            }
+        }
+
+        public static IEnumerable<string> ReadLines(string file){
+            try{
+                return File.ReadLines(file, Encoding.UTF8);
+            }catch(Exception){
+                return Enumerable.Empty<string>();
+            }
+        }
+
+        public static FileStream ReadFile(string file){
+            return new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.None);
+        }
+
+        public static void DeleteFileOnExit(string file){
+            CreatedFiles.Add(file);
+        }
+        
+        [TestClass]
+        public static class Cleanup{
+            [AssemblyCleanup]
+            public static void DeleteFilesOnExit(){
+                foreach(string file in CreatedFiles){
+                    try{
+                        File.Delete(file);
+                    }catch(Exception){
+                        // ignore
+                    }
+                }
+            }
+        }
+    }
+}

tests/UnitTests.csproj

@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{A958FA7A-4A2C-42A7-BFA0-159343483F4E}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>UnitTests</RootNamespace>
+    <AssemblyName>UnitTests</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\$(VisualStudioVersion)\UITestExtensionPackages</ReferencePath>
+    <IsCodedUITest>False</IsCodedUITest>
+    <TestProjectType>UnitTest</TestProjectType>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <PlatformTarget>x86</PlatformTarget>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <PlatformTarget>x86</PlatformTarget>
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+  </ItemGroup>
+  <Choose>
+    <When Condition="('$(VisualStudioVersion)' == '10.0' or '$(VisualStudioVersion)' == '') and '$(TargetFrameworkVersion)' == 'v3.5'">
+      <ItemGroup>
+        <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+      </ItemGroup>
+    </When>
+    <Otherwise>
+      <ItemGroup>
+        <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework" />
+      </ItemGroup>
+    </Otherwise>
+  </Choose>
+  <ItemGroup>
+    <Compile Include="Core\Settings\TestCombinedFileStream.cs" />
+    <Compile Include="Core\Utils\TestBrowserUtils.cs" />
+    <Compile Include="Core\Utils\TestCommandLineArgs.cs" />
+    <Compile Include="Core\Utils\TestCommandLineArgsParser.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="TestUtils.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\TweetDck.csproj">
+      <Project>{2389a7cd-e0d3-4706-8294-092929a33a2d}</Project>
+      <Name>TweetDck</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Choose>
+    <When Condition="'$(VisualStudioVersion)' == '10.0' And '$(IsCodedUITest)' == 'True'">
+      <ItemGroup>
+        <Reference Include="Microsoft.VisualStudio.QualityTools.CodedUITestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITest.Common, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITest.Extension, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITesting, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+      </ItemGroup>
+    </When>
+  </Choose>
+  <Import Project="$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets" Condition="Exists('$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets')" />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>