mirror of
https://github.com/chylex/TweetDuck.git
synced 2025-08-21 03:54:07 +02:00
Configuration
Core
Data
Plugins
Properties
Resources
Updates
bld
lib
TweetLib.Communication
TweetTest.System
TweetTest.Unit
Core
Data
TestCommandLineArgs.fs
TestInjectedHTML.fs
TestResult.fs
TestTwoKeyDictionary.fs
TweetTest.Unit.fsproj
packages.config
subprocess
video
.gitattributes
.gitignore
LICENSE.md
Program.cs
README.md
Reporter.cs
TweetDuck.csproj
TweetDuck.sln
TweetDuck.sln.DotSettings
packages.config
369 lines
11 KiB
Forth
369 lines
11 KiB
Forth
namespace TweetTest.Data.CommandLineArgs
|
|
|
|
open Xunit
|
|
open TweetDuck.Data
|
|
|
|
|
|
type _TestData =
|
|
|
|
static member empty
|
|
with get() = CommandLineArgs()
|
|
|
|
static member flags
|
|
with get() =
|
|
let args = CommandLineArgs()
|
|
args.AddFlag("flag1")
|
|
args.AddFlag("flag2")
|
|
args.AddFlag("flag3")
|
|
args
|
|
|
|
static member values
|
|
with get() =
|
|
let args = CommandLineArgs()
|
|
args.SetValue("val1", "hello")
|
|
args.SetValue("val2", "world")
|
|
args
|
|
|
|
static member mixed
|
|
with get() =
|
|
let args = CommandLineArgs()
|
|
args.AddFlag("flag1")
|
|
args.AddFlag("flag2")
|
|
args.AddFlag("flag3")
|
|
args.SetValue("val1", "hello")
|
|
args.SetValue("val2", "world")
|
|
args
|
|
|
|
static member duplicate
|
|
with get() =
|
|
let args = CommandLineArgs()
|
|
args.AddFlag("duplicate")
|
|
args.SetValue("duplicate", "value")
|
|
args
|
|
|
|
|
|
module Count =
|
|
|
|
[<Fact>]
|
|
let ``counts nothing correctly`` () =
|
|
Assert.Equal(0, _TestData.empty.Count)
|
|
|
|
[<Fact>]
|
|
let ``counts flags correctly`` () =
|
|
Assert.Equal(3, _TestData.flags.Count)
|
|
|
|
[<Fact>]
|
|
let ``counts values correctly`` () =
|
|
Assert.Equal(2, _TestData.values.Count)
|
|
|
|
[<Fact>]
|
|
let ``counts mixed flags and values correctly`` () =
|
|
Assert.Equal(5, _TestData.mixed.Count)
|
|
|
|
|
|
module Flags =
|
|
|
|
[<Theory>]
|
|
[<InlineData("flag1")>]
|
|
[<InlineData("flag2")>]
|
|
[<InlineData("flag3")>]
|
|
let ``HasFlag returns false if flag is missing`` (flag: string) =
|
|
Assert.False(_TestData.empty.HasFlag(flag))
|
|
Assert.False(_TestData.values.HasFlag(flag))
|
|
|
|
[<Theory>]
|
|
[<InlineData("val1")>]
|
|
[<InlineData("val2")>]
|
|
let ``HasFlag returns false if the name only specifies a key`` (flag: string) =
|
|
Assert.False(_TestData.values.HasFlag(flag))
|
|
|
|
[<Fact>]
|
|
let ``HasFlag returns true if the name specifies both a flag and a value key`` () =
|
|
Assert.True(_TestData.duplicate.HasFlag("duplicate"))
|
|
|
|
[<Theory>]
|
|
[<InlineData("flag1")>]
|
|
[<InlineData("flag2")>]
|
|
[<InlineData("flag3")>]
|
|
let ``HasFlag returns true if flag is present`` (flag: string) =
|
|
Assert.True(_TestData.flags.HasFlag(flag))
|
|
|
|
[<Theory>]
|
|
[<InlineData("FLAG1")>]
|
|
[<InlineData("FlAg1")>]
|
|
let ``HasFlag is case-insensitive`` (flag: string) =
|
|
Assert.True(_TestData.flags.HasFlag(flag))
|
|
|
|
[<Fact>]
|
|
let ``AddFlag adds new flag`` () =
|
|
let args = _TestData.flags
|
|
args.AddFlag("flag4")
|
|
|
|
Assert.Equal(4, args.Count)
|
|
Assert.True(args.HasFlag("flag4"))
|
|
|
|
[<Fact>]
|
|
let ``AddFlag does nothing if flag is already present`` () =
|
|
let args = _TestData.flags
|
|
args.AddFlag("flag1")
|
|
|
|
Assert.Equal(3, args.Count)
|
|
|
|
[<Theory>]
|
|
[<InlineData("flag1")>]
|
|
[<InlineData("flag2")>]
|
|
[<InlineData("flag3")>]
|
|
let ``RemoveFlag removes existing flag`` (flag: string) =
|
|
let args = _TestData.flags
|
|
args.RemoveFlag(flag)
|
|
|
|
Assert.Equal(2, args.Count)
|
|
Assert.False(args.HasFlag(flag))
|
|
|
|
[<Theory>]
|
|
[<InlineData("FLAG1")>]
|
|
[<InlineData("FlAg1")>]
|
|
let ``RemoveFlag is case-insensitive`` (flag: string) =
|
|
let args = _TestData.flags
|
|
args.RemoveFlag(flag)
|
|
|
|
Assert.Equal(2, args.Count)
|
|
Assert.False(args.HasFlag(flag))
|
|
|
|
[<Fact>]
|
|
let ``RemoveFlag does nothing if flag is missing`` () =
|
|
let args = _TestData.flags
|
|
args.RemoveFlag("missing")
|
|
|
|
Assert.Equal(3, args.Count)
|
|
|
|
|
|
module Values =
|
|
|
|
[<Theory>]
|
|
[<InlineData("val1")>]
|
|
[<InlineData("val2")>]
|
|
let ``HasValue returns false if key is missing`` (key: string) =
|
|
Assert.False(_TestData.empty.HasValue(key))
|
|
Assert.False(_TestData.flags.HasValue(key))
|
|
|
|
[<Theory>]
|
|
[<InlineData("flag1")>]
|
|
[<InlineData("flag2")>]
|
|
[<InlineData("flag3")>]
|
|
let ``HasValue returns false if the name specifies a flag`` (key: string) =
|
|
Assert.False(_TestData.flags.HasValue(key))
|
|
|
|
[<Fact>]
|
|
let ``HasValue returns true if the name specifies both a flag and a value key`` () =
|
|
Assert.True(_TestData.duplicate.HasValue("duplicate"))
|
|
|
|
[<Theory>]
|
|
[<InlineData("val1")>]
|
|
[<InlineData("val2")>]
|
|
let ``HasValue returns true if key is present`` (key: string) =
|
|
Assert.True(_TestData.values.HasValue(key))
|
|
|
|
[<Theory>]
|
|
[<InlineData("VAL1")>]
|
|
[<InlineData("VaL1")>]
|
|
let ``HasValue is case-insensitive`` (key: string) =
|
|
Assert.True(_TestData.values.HasValue(key))
|
|
|
|
[<Theory>]
|
|
[<InlineData("val1", "hello")>]
|
|
[<InlineData("val2", "world")>]
|
|
let ``GetValue returns correct value if key is present`` (key: string, expectedValue: string) =
|
|
Assert.Equal(expectedValue, _TestData.values.GetValue(key, ""))
|
|
|
|
[<Theory>]
|
|
[<InlineData("VAL1", "hello")>]
|
|
[<InlineData("VaL1", "hello")>]
|
|
let ``GetValue is case-insensitive`` (key: string, expectedValue: string) =
|
|
Assert.Equal(expectedValue, _TestData.values.GetValue(key, ""))
|
|
|
|
[<Fact>]
|
|
let ``GetValue returns default value if key is missing`` () =
|
|
Assert.Equal("oh no", _TestData.values.GetValue("missing", "oh no"))
|
|
|
|
[<Fact>]
|
|
let ``SetValue adds new value`` () =
|
|
let args = _TestData.values
|
|
args.SetValue("val3", "this is nice")
|
|
|
|
Assert.Equal(3, args.Count)
|
|
Assert.Equal("this is nice", args.GetValue("val3", ""))
|
|
|
|
[<Fact>]
|
|
let ``SetValue replaces existing value`` () =
|
|
let args = _TestData.values
|
|
args.SetValue("val2", "mom")
|
|
|
|
Assert.Equal(2, args.Count)
|
|
Assert.Equal("mom", args.GetValue("val2", ""))
|
|
|
|
[<Theory>]
|
|
[<InlineData("val1")>]
|
|
[<InlineData("val2")>]
|
|
let ``RemoveValue removes existing key`` (key: string) =
|
|
let args = _TestData.values
|
|
args.RemoveValue(key)
|
|
|
|
Assert.Equal(1, args.Count)
|
|
Assert.False(args.HasValue(key))
|
|
|
|
[<Theory>]
|
|
[<InlineData("VAL1")>]
|
|
[<InlineData("VaL1")>]
|
|
let ``RemoveValue is case-insensitive`` (key: string) =
|
|
let args = _TestData.values
|
|
args.RemoveValue(key)
|
|
|
|
Assert.Equal(1, args.Count)
|
|
Assert.False(args.HasValue(key))
|
|
|
|
[<Fact>]
|
|
let ``RemoveValue does nothing if key is missing`` () =
|
|
let args = _TestData.values
|
|
args.RemoveValue("missing")
|
|
|
|
Assert.Equal(2, args.Count)
|
|
|
|
|
|
module Clone =
|
|
|
|
[<Fact>]
|
|
let ``clones flags and values correctly`` () =
|
|
let clone = _TestData.mixed.Clone()
|
|
|
|
Assert.True(clone.HasFlag("flag1"))
|
|
Assert.True(clone.HasFlag("flag2"))
|
|
Assert.True(clone.HasFlag("flag3"))
|
|
Assert.Equal("hello", clone.GetValue("val1", ""))
|
|
Assert.Equal("world", clone.GetValue("val2", ""))
|
|
|
|
[<Fact>]
|
|
let ``cloning creates a new object`` () =
|
|
let args = _TestData.mixed
|
|
|
|
Assert.NotSame(args.Clone(), args)
|
|
|
|
[<Fact>]
|
|
let ``modifying a clone does not modify the original`` () =
|
|
let original = _TestData.mixed
|
|
let clone = original.Clone()
|
|
|
|
clone.RemoveFlag("flag1")
|
|
clone.AddFlag("flag4")
|
|
clone.SetValue("val1", "goodbye")
|
|
|
|
Assert.True(original.HasFlag("flag1"))
|
|
Assert.False(original.HasFlag("flag4"))
|
|
Assert.Equal("hello", original.GetValue("val1", ""))
|
|
|
|
|
|
module ToDictionary =
|
|
open System.Collections.Generic
|
|
|
|
[<Fact>]
|
|
let ``does nothing with empty args`` () =
|
|
let dict = Dictionary<string, string>()
|
|
_TestData.empty.ToDictionary(dict)
|
|
|
|
Assert.Equal(0, dict.Count)
|
|
|
|
[<Fact>]
|
|
let ``converts flags and values correctly`` () =
|
|
let dict = Dictionary<string, string>()
|
|
_TestData.mixed.ToDictionary(dict)
|
|
|
|
Assert.Equal(5, dict.Count)
|
|
Assert.Equal("1", dict.["flag1"])
|
|
Assert.Equal("1", dict.["flag2"])
|
|
Assert.Equal("1", dict.["flag3"])
|
|
Assert.Equal("hello", dict.["val1"])
|
|
Assert.Equal("world", dict.["val2"])
|
|
|
|
[<Fact>]
|
|
let ``prefers value if the same name is used for a flag and value`` () =
|
|
let dict = Dictionary<string, string>()
|
|
_TestData.duplicate.ToDictionary(dict)
|
|
|
|
Assert.Equal(1, dict.Count)
|
|
Assert.Equal("value", dict.["duplicate"])
|
|
|
|
|
|
module ToString =
|
|
|
|
[<Fact>]
|
|
let ``returns empty string for empty args`` () =
|
|
Assert.Equal("", _TestData.empty.ToString())
|
|
|
|
[<Fact>]
|
|
let ``converts flags and values correctly`` () =
|
|
Assert.Equal("flag1 flag2 flag3 val1 \"hello\" val2 \"world\"", _TestData.mixed.ToString())
|
|
// not guaranteed to be in order but works for now
|
|
|
|
[<Fact>]
|
|
let ``handle duplicate names in a probably pretty decent way tbh`` () =
|
|
Assert.Equal("duplicate duplicate \"value\"", _TestData.duplicate.ToString())
|
|
|
|
|
|
module FromStringArray =
|
|
|
|
[<Fact>]
|
|
let ``returns empty args if input array is empty`` () =
|
|
Assert.Equal(0, CommandLineArgs.FromStringArray('-', Array.empty).Count)
|
|
|
|
[<Fact>]
|
|
let ``returns empty args if no entry starts with entry char`` () =
|
|
Assert.Equal(0, CommandLineArgs.FromStringArray('-', [| ""; "~nope"; ":fail" |]).Count)
|
|
|
|
[<Fact>]
|
|
let ``reads flags and values correctly`` () =
|
|
let args = CommandLineArgs.FromStringArray('-', [| "-flag1"; "-flag2"; "-flag3"; "-val1"; "first value"; "-val2"; "second value" |])
|
|
|
|
Assert.Equal(5, args.Count)
|
|
Assert.True(args.HasFlag("-flag1"))
|
|
Assert.True(args.HasFlag("-flag2"))
|
|
Assert.True(args.HasFlag("-flag3"))
|
|
Assert.Equal("first value", args.GetValue("-val1", ""))
|
|
Assert.Equal("second value", args.GetValue("-val2", ""))
|
|
|
|
|
|
module ReadCefArguments =
|
|
|
|
[<Fact>]
|
|
let ``returns empty args if input string is empty`` () =
|
|
Assert.Equal(0, CommandLineArgs.ReadCefArguments("").Count)
|
|
|
|
[<Fact>]
|
|
let ``returns empty args if input string is whitespace`` () =
|
|
Assert.Equal(0, CommandLineArgs.ReadCefArguments(" \r\n \t").Count)
|
|
|
|
[<Fact>]
|
|
let ``reads values correctly`` () =
|
|
let args = CommandLineArgs.ReadCefArguments("--first-value=10 --second-value=\"long string with spaces\"")
|
|
|
|
Assert.Equal(2, args.Count)
|
|
Assert.Equal("10", args.GetValue("first-value", ""))
|
|
Assert.Equal("long string with spaces", args.GetValue("second-value", ""))
|
|
|
|
[<Fact>]
|
|
let ``reads flags as value keys with values of 1`` () =
|
|
let args = CommandLineArgs.ReadCefArguments("--first-flag-as-value --second-flag-as-value")
|
|
|
|
Assert.Equal(2, args.Count)
|
|
Assert.Equal("1", args.GetValue("first-flag-as-value", ""))
|
|
Assert.Equal("1", args.GetValue("second-flag-as-value", ""))
|
|
|
|
[<Fact>]
|
|
let ``reads complex string with whitespace correctly`` () =
|
|
let args = CommandLineArgs.ReadCefArguments("\t--first-value=55.5\r\n--first-flag-as-value\r\n --second-value=\"long string\"\t--second-flag-as-value ")
|
|
|
|
Assert.Equal(4, args.Count)
|
|
Assert.Equal("55.5", args.GetValue("first-value", ""))
|
|
Assert.Equal("long string", args.GetValue("second-value", ""))
|
|
Assert.Equal("1", args.GetValue("first-flag-as-value", ""))
|
|
Assert.Equal("1", args.GetValue("second-flag-as-value", ""))
|