internal class WindowApplicationSettings : ApplicationSettingsBase
{
    public WindowApplicationSettings(WindowSettings windowSettings)
        : base(windowSettings._window.GetType().FullName)
    {}

    [UserScopedSetting]
    public WINDOWPLACEMENT? Placement
    {
        get
        {
            if (this["Placement"] != null)
                return ((WINDOWPLACEMENT)this["Placement"]);
            return null;
        }
        set
        {
            this["Placement"] = value;
        }
    }
}

public static readonly DependencyProperty SaveProperty
   = DependencyProperty.RegisterAttached(“Save”, typeof(bool), typeof(WindowSettings),
        new FrameworkPropertyMetadata(new PropertyChangedCallback(OnSaveInvalidated)));

private static void OnSaveInvalidated(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
{
    var window = dependencyObject as Window;
    if (window == null || !((bool) e.NewValue)) return;
    var settings = new WindowSettings(window);
    settings.Attach();
}

private void Attach()
{
    if (_window == null) return;
    _window.Closing += WindowClosing;
    _window.SourceInitialized += WindowSourceInitialized;
}

void WindowSourceInitialized(object sender, EventArgs e)
{
    LoadWindowState();
}

private void WindowClosing(object sender, CancelEventArgs e)
{
    SaveWindowState();
    _window.Closing -= WindowClosing;
    _window.SourceInitialized -= WindowSourceInitialized;
    _window = null;
}

protected virtual void LoadWindowState()
{
    Settings.Reload();

    if (Settings.Placement == null) return;
    try
    {
        var wp = Settings.Placement.Value;

        wp.length = Marshal.SizeOf(typeof (WINDOWPLACEMENT));
        wp.flags = 0;
        wp.showCmd = (wp.showCmd == SW_SHOWMINIMIZED ? SW_SHOWNORMAL : wp.showCmd);
        var hwnd = new WindowInteropHelper(_window).Handle;
        SetWindowPlacement(hwnd, ref wp);
    }
    catch (Exception ex)
    {
        Debug.WriteLine(string.Format(“Failed to load window state:\r\n{0}”, ex));
    }
}

protected virtual void SaveWindowState()
{
    WINDOWPLACEMENT wp;
    var hwnd = new WindowInteropHelper(_window).Handle;
    GetWindowPlacement(hwnd, out wp);
    Settings.Placement = wp;
    Settings.Save();
}

<userSettings>
        <ioWpf.WindowSettings_x002B_WindowApplicationSettings.ParameterPopulator.Views.MainView>
            <setting name=“Placement“ serializeAs=“Xml“>
                <value>
                    <WINDOWPLACEMENT xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance“
                        xmlns:xsd=“http://www.w3.org/2001/XMLSchema“>
                        <length>44</length>
                        <flags>0</flags>
                        <showCmd>1</showCmd>
                        <minPosition>
                            <X>-1</X>
                            <Y>-1</Y>
                        </minPosition>
                        <maxPosition>
                            <X>-1</X>
                            <Y>-1</Y>
                        </maxPosition>
                        <normalPosition>
                            <Left>93</Left>
                            <Top>371</Top>
                            <Right>893</Right>
                            <Bottom>771</Bottom>
                        </normalPosition>
                    </WINDOWPLACEMENT>
                </value>
            </setting>
        </ioWpf.WindowSettings_x002B_WindowApplicationSettings.ParameterPopulator.Views.MainView>
    </userSettings>

using System;
using System.ComponentModel;
using System.Configuration;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Interop;

namespace ioWpf
{
    /// <summary>
    /// Persists a Window’s Size, Location and WindowState to UserScopeSettings
    /// </summary>
    public class WindowSettings
    {
        [DllImport("user32.dll")]
        static extern bool SetWindowPlacement(IntPtr hWnd, [In] ref WINDOWPLACEMENT lpwndpl);

        [DllImport("user32.dll")]
        static extern bool GetWindowPlacement(IntPtr hWnd, out WINDOWPLACEMENT lpwndpl);

        // ReSharper disable InconsistentNaming
        const int SW_SHOWNORMAL = 1;
        const int SW_SHOWMINIMIZED = 2;
        // ReSharper restore InconsistentNaming

        internal class WindowApplicationSettings : ApplicationSettingsBase
        {
            public WindowApplicationSettings(WindowSettings windowSettings)
                : base(windowSettings._window.GetType().FullName)
            {}

            [UserScopedSetting]
            public WINDOWPLACEMENT? Placement
            {
                get
                {
                    if (this["Placement"] != null)
                        return ((WINDOWPLACEMENT)this["Placement"]);
                    return null;
                }
                set
                {
                    this["Placement"] = value;
                }
            }
        }
        private Window _window;

        public WindowSettings(Window window)
        {
            _window = window;
        }

        public static readonly DependencyProperty SaveProperty
           = DependencyProperty.RegisterAttached(“Save”, typeof(bool), typeof(WindowSettings),
                new FrameworkPropertyMetadata(new PropertyChangedCallback(OnSaveInvalidated)));

        private static void OnSaveInvalidated(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
        {
            var window = dependencyObject as Window;
            if (window == null || !((bool) e.NewValue)) return;
            var settings = new WindowSettings(window);
            settings.Attach();
        }

        private void Attach()
        {
            if (_window == null) return;
            _window.Closing += WindowClosing;
            _window.SourceInitialized += WindowSourceInitialized;
        }

        void WindowSourceInitialized(object sender, EventArgs e)
        {
            LoadWindowState();
        }

        private void WindowClosing(object sender, CancelEventArgs e)
        {
            SaveWindowState();
            _window.Closing -= WindowClosing;
            _window.SourceInitialized -= WindowSourceInitialized;
            _window = null;
        }

        protected virtual void LoadWindowState()
        {
            Settings.Reload();

            if (Settings.Placement == null) return;
            try
            {
                var wp = Settings.Placement.Value;

                wp.length = Marshal.SizeOf(typeof (WINDOWPLACEMENT));
                wp.flags = 0;
                wp.showCmd = (wp.showCmd == SW_SHOWMINIMIZED ? SW_SHOWNORMAL : wp.showCmd);
                var hwnd = new WindowInteropHelper(_window).Handle;
                SetWindowPlacement(hwnd, ref wp);
            }
            catch (Exception ex)
            {
                Debug.WriteLine(string.Format(“Failed to load window state:\r\n{0}”, ex));
            }
        }

        protected virtual void SaveWindowState()
        {
            WINDOWPLACEMENT wp;
            var hwnd = new WindowInteropHelper(_window).Handle;
            GetWindowPlacement(hwnd, out wp);
            Settings.Placement = wp;
            Settings.Save();
        }

        private WindowApplicationSettings _windowApplicationSettings;

        internal virtual WindowApplicationSettings CreateWindowApplicationSettingsInstance()
        {
            return new WindowApplicationSettings(this);
        }

        [Browsable(false)]
        internal WindowApplicationSettings Settings
        {
            get
            {
                if (_windowApplicationSettings == null)
                {
                    _windowApplicationSettings = CreateWindowApplicationSettingsInstance();
                }
                return _windowApplicationSettings;
            }
        }
    }

    // ReSharper disable InconsistentNaming
    // RECT structure required by WINDOWPLACEMENT structure
    [Serializable]
    [StructLayout(LayoutKind.Sequential)]
    public struct RECT
    {
        private int _left;
        private int _top;
        private int _right;
        private int _bottom;

        public RECT(int left, int top, int right, int bottom)
        {
            _left = left;
            _top = top;
            _right = right;
            _bottom = bottom;
        }

        public override bool Equals(object obj)
        {
            if (obj is RECT)
            {
                var rect = (RECT)obj;

                return rect._bottom == _bottom &&
                       rect._left == _left &&
                       rect._right == _right &&
                       rect._top == _top;
            }
            return base.Equals(obj);
        }

        public override int GetHashCode()
        {
            return _bottom.GetHashCode() ^
                   _left.GetHashCode() ^
                   _right.GetHashCode() ^
                   _top.GetHashCode();
        }

        public static bool operator ==(RECT a, RECT b)
        {
            return a._bottom == b._bottom &&
                   a._left == b._left &&
                   a._right == b._right &&
                   a._top == b._top;
        }

        public static bool operator !=(RECT a, RECT b)
        {
            return !(a == b);
        }

        public int Left
        {
            get { return _left; }
            set { _left = value; }
        }

        public int Top
        {
            get { return _top; }
            set { _top = value; }
        }

        public int Right
        {
            get { return _right; }
            set { _right = value; }
        }

        public int Bottom
        {
            get { return _bottom; }
            set { _bottom = value; }
        }
    }

    // POINT structure required by WINDOWPLACEMENT structure
    [Serializable]
    [StructLayout(LayoutKind.Sequential)]
    public struct POINT
    {
        private int _x;
        private int _y;

        public POINT(int x, int y)
        {
            _x = x;
            _y = y;
        }

        public int X
        {
            get { return _x; }
            set { _x = value; }
        }

        public int Y
        {
            get { return _y; }
            set { _y = value; }
        }

        public override bool Equals(object obj)
        {
            if (obj is POINT)
            {
                var point = (POINT)obj;

                return point._x == _x && point._y == _y;
            }
            return base.Equals(obj);
        }
        public override int GetHashCode()
        {
            return _x.GetHashCode() ^ _y.GetHashCode();
        }

        public static bool operator ==(POINT a, POINT b)
        {
            return a._x == b._x && a._y == b._y;
        }

        public static bool operator !=(POINT a, POINT b)
        {
            return !(a == b);
        }
    }

    // WINDOWPLACEMENT stores the position, size, and state of a window
    [Serializable]
    [StructLayout(LayoutKind.Sequential)]
    public struct WINDOWPLACEMENT
    {
        public int length;
        public int flags;
        public int showCmd;
        public POINT minPosition;
        public POINT maxPosition;
        public RECT normalPosition;
    }
    // ReSharper restore InconsistentNaming
}

<Window x:Class=”FacebookSync.Views.ConfigurationView”
   xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”
   xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”
   Height=”300″ Width=”300″>
    <Grid>
        
    </Grid>
</Window>

namespace FacebookSync.Views
{
    public partial class ConfigurationView
    {
        public ConfigurationView()
        {
            InitializeComponent();
        }
    }
}

<TextBlock Text=”Hello world” />

private static void ConfigButtonClick(object sender, CommandBarEventArgs e)
{
    var configurationViewModel = new ConfigurationViewModel(Globals.ThisAddIn.Settings);
    var configurationView = new ConfigurationView {DataContext = configurationViewModel};
    configurationView.ShowDialog();
}

public SyncMode SyncMode
{
    get
    {
        string syncModeSetting = _settings.ReadSetting(“SyncMode”);
        int syncMode;

        if (syncModeSetting == null || !int.TryParse(syncModeSetting, out syncMode))
            return SyncMode.Manual;

        return (SyncMode)syncMode;
    }
    set
    {
        _settings.WriteSetting(“SyncMode”, ((int)value).ToString());
        OnPropertyChanged(“SyncMode”);
    }
}

public IList<UserFacebookEvent> GetEvents()
{
    var api = new facebook.API
                  {
                      ApplicationKey = ApiKey,
                      Secret = Secret
                  };
    api.ConnectToFacebook();

    var events = new List<UserFacebookEvent> ();

    events.AddRange(
        api
        .events
        .get(null, null, DateTime.Now, null, “attending”)
        .Select(e => new UserFacebookEvent(e, RsvpStatus.Attending)));

    events.AddRange(
        api
        .events
        .get(null, null, DateTime.Now, null, “unsure”)
        .Select(e => new UserFacebookEvent(e, RsvpStatus.Unsure)));

    events.AddRange(
        api
        .events
        .get(null, null, DateTime.Now, null, “declined”)
        .Select(e => new UserFacebookEvent(e, RsvpStatus.Declined)));

    events.AddRange(
        api
        .events
        .get(null, null, DateTime.Now, null, “not_replied”)
        .Select(e => new UserFacebookEvent(e, RsvpStatus.NotReplied)));

    return events;
}

var facebookTimeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(“Pacific Standard Time”);

var startTime = TimeZoneInfo.ConvertTime(new DateTime(1970, 1, 1).AddSeconds(facebookEvent.start_time),
    TimeZoneInfo.Utc,
    facebookTimeZoneInfo);

var endTime = TimeZoneInfo.ConvertTime(new DateTime(1970, 1, 1).AddSeconds(facebookEvent.end_time),
    TimeZoneInfo.Utc,
    facebookTimeZoneInfo);

public UIElement Child
{
    get
    {
        return elementHost1.Child;
    }
    set
    {
        elementHost1.Child = value;
        elementHost1.Width++;
        elementHost1.Dock = DockStyle.Fill;
    }
}

var commandLine = Environment.CommandLine;
var splitCommandLine = Arguments.SplitCommandLine(commandLine);

var arguments = new Arguments(splitCommandLine);

static int Main(string[] args)
{
    _args = new Arguments(args);
}

public class Arguments
{
    /// <summary>
    /// Splits the command line. When main(string[] args) is used escaped quotes (ie a path “c:\folder\”)
    /// Will consume all the following command line arguments as the one argument.
    /// This function ignores escaped quotes making handling paths much easier.
    /// </summary>
    /// <param name=”commandLine”>The command line.</param>
    /// <returns></returns>
    public static string[] SplitCommandLine(string commandLine)
    {
        var translatedArguments = new StringBuilder(commandLine);
        var escaped = false;
        for (var i = 0; i < translatedArguments.Length; i++)
        {
            if (translatedArguments[i] == ‘”‘)
            {
                escaped = !escaped;
            }
            if (translatedArguments[i] == ‘ ‘ && !escaped)
            {
                translatedArguments[i] = ‘\n’;
            }
        }

        var toReturn = translatedArguments.ToString().Split(new[] { ‘\n’ }, StringSplitOptions.RemoveEmptyEntries);
        for (var i = 0; i < toReturn.Length; i++)
        {
            toReturn[i] = RemoveMatchingQuotes(toReturn[i]);
        }
        return toReturn;
    }

    public static string RemoveMatchingQuotes(string stringToTrim)
    {
        var firstQuoteIndex = stringToTrim.IndexOf(‘”‘);
        var lastQuoteIndex = stringToTrim.LastIndexOf(‘”‘);
        while (firstQuoteIndex != lastQuoteIndex)
        {
            stringToTrim = stringToTrim.Remove(firstQuoteIndex, 1);
            stringToTrim = stringToTrim.Remove(lastQuoteIndex – 1, 1); //-1 because we’ve shifted the indicies left by one
            firstQuoteIndex = stringToTrim.IndexOf(‘”‘);
            lastQuoteIndex = stringToTrim.LastIndexOf(‘”‘);
        }

        return stringToTrim;
    }

    private readonly Dictionary<string, Collection<string>> _parameters;
    private string _waitingParameter;

    public Arguments(IEnumerable<string> arguments)
    {
        _parameters = new Dictionary<string, Collection<string>>();

        string[] parts;
        
        //Splits on beginning of arguments ( – and — and / )
        //And on assignment operators ( = and : )
        var argumentSplitter = new Regex(@”^-{1,2}|^/|=|:”,
            RegexOptions.IgnoreCase | RegexOptions.Compiled);

        foreach (var argument in arguments)
        {
            parts = argumentSplitter.Split(argument, 3);
            switch (parts.Length)
            {
                case 1:
                    AddValueToWaitingArgument(parts[0]);
                    break;
                case 2:
                    AddWaitingArgumentAsFlag();

                    //Because of the split index 0 will be a empty string
                    _waitingParameter = parts[1];
                    break;
                case 3:
                    AddWaitingArgumentAsFlag();

                    //Because of the split index 0 will be a empty string
                    string valuesWithoutQuotes = RemoveMatchingQuotes(parts[2]);

                    AddListValues(parts[1], valuesWithoutQuotes.Split(‘,’));
                    break;
            }
        }

        AddWaitingArgumentAsFlag();
    }

    private void AddListValues(string argument, IEnumerable<string> values)
    {
        foreach (var listValue in values)
        {
            Add(argument, listValue);
        }
    }

    private void AddWaitingArgumentAsFlag()
    {
        if (_waitingParameter == null) return;

        AddSingle(_waitingParameter, “true”);
        _waitingParameter = null;
    }

    private void AddValueToWaitingArgument(string value)
    {
        if (_waitingParameter == null) return;

        value = RemoveMatchingQuotes(value);

        Add(_waitingParameter, value);
        _waitingParameter = null;
    }

    /// <summary>
    /// Gets the count.
    /// </summary>
    /// <value>The count.</value>
    public int Count
    {
        get
        {
            return _parameters.Count;
        }
    }

    /// <summary>
    /// Adds the specified argument.
    /// </summary>
    /// <param name=”argument”>The argument.</param>
    /// <param name=”value”>The value.</param>
    public void Add(string argument, string value)
    {
        if (!_parameters.ContainsKey(argument))
            _parameters.Add(argument, new Collection<string>());

        _parameters[argument].Add(value);
    }

    public void AddSingle(string argument, string value)
    {
        if (!_parameters.ContainsKey(argument))
            _parameters.Add(argument, new Collection<string>());
        else
            throw new ArgumentException(string.Format(“Argument {0} has already been defined”, argument));

        _parameters[argument].Add(value);
    }

    public void Remove(string argument)
    {
        if (_parameters.ContainsKey(argument))
            _parameters.Remove(argument);
    }

    /// <summary>
    /// Determines whether the specified argument is true.
    /// </summary>
    /// <param name=”argument”>The argument.</param>
    /// <returns>
    ///     <c>true</c> if the specified argument is true; otherwise, <c>false</c>.
    /// </returns>
    public bool IsTrue(string argument)
    {
        AssertSingle(argument);

        var arg = this[argument];
        
        return arg != null && arg[0].Equals(“true”, StringComparison.OrdinalIgnoreCase);
    }

    private void AssertSingle(string argument)
    {
        if (this[argument] != null && this[argument].Count > 1)
            throw new ArgumentException(string.Format(“{0} has been specified more than once, expecting single value”, argument));
    }

    public string Single(string argument)
    {
        AssertSingle(argument);

        //only return value if its NOT true, there is only a single item for that argument
        //and the argument is defined
        if (this[argument] != null && !IsTrue(argument))
            return this[argument][0];
        
        return null;
    }

    public bool Exists(string argument)
    {
        return (this[argument] != null && this[argument].Count > 0);
    }

    /// <summary>
    /// Gets the <see cref=”System.Collections.ObjectModel.Collection&lt;T&gt;”/> with the specified parameter.
    /// </summary>
    /// <value></value>
    public Collection<string> this[string parameter]
    {
        get
        {
            return _parameters.ContainsKey(parameter) ? _parameters[parameter] : null;
        }
    }
}

[TestClass]
public class ArgumentsTests
{
    public TestContext TestContext { get; set; }

    /// <summary>
    ///A test for Arguments Constructor
    ///</summary>
    [TestMethod]
    public void ArgumentBooleanTest()
    {
        IEnumerable<string> args = new[]
                                       {
                                           “-testBool”
                                       };
        var target = new Arguments(args);
        Assert.IsTrue(target.IsTrue(“testBool”));
    }

    [TestMethod]
    public void IsTrueDoesntExist()
    {
        IEnumerable<string> args = new string[]{};
        var target = new Arguments(args);
        Assert.IsFalse(target.IsTrue(“doesntExist”));
    }

    [TestMethod]
    public void ArgumentDoubleDashesTest()
    {
        IEnumerable<string> args = new[]
                                       {
                                           “–testArg=Value”
                                       };
        var target = new Arguments(args);
        Assert.AreEqual(“Value”, target.Single(“testArg”));
    }

    [TestMethod]
    public void ArgumentSingleTest()
    {
        IEnumerable<string> args = new[]
                                       {
                                           “-test:Value”
                                       };
        var target = new Arguments(args);
        Assert.AreEqual(1, target["test"].Count);
        Assert.AreEqual(“Value”, target.Single(“test”));
    }

    [TestMethod]
    public void ArgumentWithSpaceSeparatorTest()
    {
        IEnumerable<string> args = Arguments.SplitCommandLine(“-test Value”);

        var target = new Arguments(args);
        Assert.AreEqual(1, target["test"].Count);
        Assert.AreEqual(“Value”, target.Single(“test”));
    }

    [TestMethod]
    public void ArgumentWithSpaceSeparatorAndSpaceInValueTest()
    {
        IEnumerable<string> args = Arguments.SplitCommandLine(“-test \”Value With Space\”");

        var target = new Arguments(args);
        Assert.AreEqual(1, target["test"].Count);
        Assert.AreEqual(“Value With Space”, target.Single(“test”));
    }

    [TestMethod]
    public void AddWaitingAsFlagTest()
    {
        IEnumerable<string> args = Arguments.SplitCommandLine(“-flag -test \”Value With Space\”");

        var target = new Arguments(args);
        Assert.AreEqual(2, target.Count);
        Assert.AreEqual(1, target["test"].Count);
        Assert.AreEqual(“Value With Space”, target.Single(“test”));
        Assert.IsTrue(target.IsTrue(“flag”));
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void AddSingleTwiceTest()
    {
        IEnumerable<string> args = Arguments.SplitCommandLine(“-flag”);

        var target = new Arguments(args);

        target.AddSingle(“flag”, “true”);
    }

    [TestMethod]
    public void FlagsTest()
    {
        IEnumerable<string> args = Arguments.SplitCommandLine(“-flag1 -flag2″);

        var target = new Arguments(args);

        Assert.IsTrue(target.IsTrue(“flag1″));
        Assert.IsTrue(target.IsTrue(“flag2″));
    }

    [TestMethod]
    public void RemoveTest()
    {
        IEnumerable<string> args = Arguments.SplitCommandLine(“-flag1 -flag2″);

        var target = new Arguments(args);

        Assert.IsTrue(target.IsTrue(“flag1″));
        Assert.IsTrue(target.IsTrue(“flag2″));
        target.Remove(“flag1″);
        Assert.IsFalse(target.Exists(“flag1″));
        Assert.IsTrue(target.IsTrue(“flag2″));
    }

    [TestMethod]
    public void SingleReturnsNullIfNotDefinedTest()
    {

        var target = new Arguments(new string[]{});

        Assert.IsFalse(target.Exists(“notDefined”));
        Assert.IsNull(target.Single(“notDefined”));
    }

    [TestMethod]
    public void ExistsTest()
    {
        IEnumerable<string> args = Arguments.SplitCommandLine(“-flag1″);

        var target = new Arguments(args);

        Assert.IsTrue(target.Exists(“flag1″));
    }

    [TestMethod]
    public void ArgumentListTest()
    {
        IEnumerable<string> args = new[]
                                       {
                                           “-test:Value”,
                                           “-test:Value2″
                                       };
        var target = new Arguments(args);
        Assert.AreEqual(2, target["test"].Count);
        Assert.AreEqual(“Value”, target["test"][0]);
        Assert.AreEqual(“Value2″, target["test"][1]);
    }

    [TestMethod]
    public void ArgumentPathTest()
    {
        IEnumerable<string> args = new[]
                                       {
                                           “-test:Value”,
                                           @”-test:C:\Folder\”
                                       };
        var target = new Arguments(args);
        Assert.AreEqual(2, target["test"].Count);
        Assert.AreEqual(“Value”, target["test"][0]);
        Assert.AreEqual(@”C:\Folder\”, target["test"][1]);
    }

    [TestMethod]
    public void ArgumentQuotedPathTest()
    {
        IEnumerable<string> args = new[]
                                       {
                                           “-test:Value”,
                                           “-test:\”C:\\Folder\\\”"
                                       };
        var target = new Arguments(args);
        Assert.AreEqual(2, target["test"].Count);
        Assert.AreEqual(“Value”, target["test"][0]);
        Assert.AreEqual(“C:\\Folder\\”, target["test"][1]);
    }

    [TestMethod]
    public void ArgumentQuotedPathWithSpaceTest()
    {
        IEnumerable<string> args = new[]
                                       {
                                           “-test:Value”,
                                           “-test:\”C:\\Folder Name\\\”"
                                       };
        var target = new Arguments(args);
        Assert.AreEqual(2, target["test"].Count);
        Assert.AreEqual(“Value”, target["test"][0]);
        Assert.AreEqual(“C:\\Folder Name\\”, target["test"][1]);
    }

    [TestMethod]
    public void ArgumentQuotedPathWithSpaceAndFollowingArgTest()
    {
        IEnumerable<string> args = new[]
                                       {
                                           “-test:Value”,
                                           “-test:\”C:\\Folder Name\\\”",
                                           “-testPath:\”C:\\Folder2\\\”",
                                           “-boolArg”
                                       };

        var target = new Arguments(args);
        Assert.AreEqual(2, target["test"].Count);
        Assert.AreEqual(@”C:\Folder2\”, target.Single(“testPath”));
        Assert.IsTrue(target.IsTrue(“boolArg”));

        Assert.AreEqual(“Value”, target["test"][0]);
        Assert.AreEqual(“C:\\Folder Name\\”, target["test"][1]);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ArgumentListRequestSingleThrowsExceptionTest()
    {
        IEnumerable<string> args = new[]
                                       {
                                           “-test:Value”,
                                           “-test:Value2″
                                       };

        var target = new Arguments(args);
        //Should throw Argument exception because test is defined more than once
        target.Single(“test”);
    }

    [TestMethod]
    public void ArgumentCommaListTest()
    {
        IEnumerable<string> args = new[]
                                       {
                                           “-testList:Value,Value2,Value3″
                                       };

        var target = new Arguments(args);
        Assert.AreEqual(3, target["testList"].Count);

        Assert.AreEqual(“Value”, target["testList"][0]);
        Assert.AreEqual(“Value2″, target["testList"][1]);
        Assert.AreEqual(“Value3″, target["testList"][2]);
    }
\