chylex/TweetDuck
1
0
Fork 0
mirror of https://github.com/chylex/TweetDuck.git synced 2025-05-10 08:34:06 +02:00
Code

Rewrite unit tests for TwoKeyDictionary into xUnit

Browse Source
This commit is contained in:
chylex 2018-07-03 21:23:34 +02:00
parent d7378bd75a
commit 830d98a101
4 changed files with 234 additions and 218 deletions

233
lib/TweetTest.Unit/Data/TestTwoKeyDictionary.fs Normal file
View File

@ -0,0 +1,233 @@
namespace Unit.Data.TwoKeyDictionary
open Xunit
open TweetDuck.Data
open System.Collections.Generic
type _TestData =
static member empty
with get() = TwoKeyDictionary<string, int, float>()
static member uniquevals
with get() =
let dict = TwoKeyDictionary<string, int, float>()
dict.Add("first", 1, 10.0)
dict.Add("first", 2, 20.0)
dict.Add("first", 3, 30.0)
dict.Add("second", 1, 100.0)
dict.Add("second", 2, 200.0)
dict.Add("third", 1, 1000.0)
dict
static member duplicatevals
with get() =
let dict = TwoKeyDictionary<string, int, float>()
dict.Add("first", 1, 10.0)
dict.Add("first", 2, 20.0)
dict.Add("first", 3, 30.0)
dict.Add("second", 1, 10.0)
dict.Add("second", 2, 20.0)
dict.Add("third", 1, 10.0)
dict
module Indexer =
[<Theory>]
[<InlineData("first", 3, 30.0)>]
[<InlineData("second", 2, 200.0)>]
[<InlineData("third", 1, 1000.0)>]
let ``get returns correct value`` (outerKey: string, innerKey: int, value: float) =
Assert.Equal(value, _TestData.uniquevals.[outerKey, innerKey])
[<Fact>]
let ``get throws if outer key is missing`` () =
Assert.Throws<KeyNotFoundException>(fun () -> _TestData.uniquevals.["missing", 1] |> ignore)
[<Fact>]
let ``get throws if inner key is missing`` () =
Assert.Throws<KeyNotFoundException>(fun () -> _TestData.uniquevals.["first", 0] |> ignore)
[<Fact>]
let ``set correctly updates value`` () =
let copy = _TestData.uniquevals
copy.["first", 1] <- 50.0
Assert.Equal(50.0, copy.["first", 1])
[<Fact>]
let ``set creates new inner key`` () =
let copy = _TestData.uniquevals
copy.["second", 3] <- 300.0
Assert.Equal(300.0, copy.["second", 3])
[<Fact>]
let ``set creates new outer key`` () =
let copy = _TestData.uniquevals
copy.["fourth", 1] <- 10000.0
Assert.Equal(10000.0, copy.["fourth", 1])
module InnerValues =
open System.Linq
[<Fact>]
let ``returns empty collection for empty dictionary`` () =
Assert.Equal<IEnumerable<float>>(Enumerable.Empty<float>(), _TestData.empty.InnerValues)
[<Fact>]
let ``returns all values for dictionary with unique values`` () =
Assert.Equal([ 10.0; 20.0; 30.0; 100.0; 200.0; 1000.0 ], _TestData.uniquevals.InnerValues)
[<Fact>]
let ``returns all values for dictionary with duplicated values`` () =
Assert.Equal([ 10.0; 20.0; 30.0; 10.0; 20.0; 10.0 ], _TestData.duplicatevals.InnerValues)
module TryGetValue =
[<Fact>]
let ``returns true and correct value for existing key`` () =
let (success, result) = _TestData.uniquevals.TryGetValue("first", 3)
Assert.True(success)
Assert.Equal(30.0, result)
[<Fact>]
let ``returns false for missing inner key`` () =
Assert.False(_TestData.uniquevals.TryGetValue("first", 0, ref 0.0))
[<Fact>]
let ``returns false for missing outer key`` () =
Assert.False(_TestData.uniquevals.TryGetValue("missing", 0, ref 0.0))
module Add =
open System
[<Fact>]
let ``creates new inner key`` () =
let copy = _TestData.uniquevals
copy.Add("first", 4, 40.0)
Assert.Equal(40.0, copy.["first", 4])
[<Fact>]
let ``creates new outer key`` () =
let copy = _TestData.uniquevals
copy.Add("fourth", 1, 10000.0)
Assert.Equal(10000.0, copy.["fourth", 1])
[<Fact>]
let ``throw on duplicate key`` () =
Assert.Throws<ArgumentException>(fun () -> _TestData.uniquevals.Add("first", 2, 25.0))
module Contains =
[<Theory>]
[<InlineData("first")>]
[<InlineData("second")>]
[<InlineData("third")>]
let ``returns true if outer key exists`` (outerKey: string) =
Assert.True(_TestData.uniquevals.Contains(outerKey))
[<Theory>]
[<InlineData(1)>]
[<InlineData(2)>]
[<InlineData(3)>]
let ``returns true if inner key exists`` (innerKey: int) =
Assert.True(_TestData.uniquevals.Contains("first", innerKey))
[<Fact>]
let ``returns false if outer key does not exist`` () =
Assert.False(_TestData.uniquevals.Contains("missing"))
[<Fact>]
let ``returns false if inner key does not exist`` () =
Assert.False(_TestData.uniquevals.Contains("first", 0))
module Count =
[<Fact>]
let ``counts all values for dictionary with unique values`` () =
Assert.Equal(6, _TestData.uniquevals.Count())
[<Fact>]
let ``counts all values for dictionary with duplicated values`` () =
Assert.Equal(6, _TestData.duplicatevals.Count())
[<Theory>]
[<InlineData("first", 3)>]
[<InlineData("second", 2)>]
[<InlineData("third", 1)>]
let ``counts all values for specified key`` (outerKey: string, expectedCount: int) =
Assert.Equal(expectedCount, _TestData.uniquevals.Count(outerKey))
[<Fact>]
let ``throws on missing key`` () =
Assert.Throws<KeyNotFoundException>(fun () -> _TestData.uniquevals.Count("missing") |> ignore)
module Clear =
[<Fact>]
let ``clears all values for all keys`` () =
let copy = _TestData.uniquevals
copy.Clear()
Assert.Equal(0, copy.Count())
[<Fact>]
let ``clears all values for specified key`` () =
let copy = _TestData.uniquevals
copy.Clear("first")
Assert.True(copy.Contains("first"))
Assert.Equal(0, copy.Count("first"))
Assert.Equal(3, copy.Count())
[<Fact>]
let ``throws on missing key`` () =
Assert.Throws<KeyNotFoundException>(fun () -> _TestData.uniquevals.Clear("missing") |> ignore)
module Remove =
[<Fact>]
let ``removes value by key pair`` () =
let copy = _TestData.uniquevals
Assert.True(copy.Remove("first", 3))
Assert.False(copy.Contains("first", 3))
Assert.Equal(5, copy.Count())
[<Fact>]
let ``removes inner key and its values`` () =
let copy = _TestData.uniquevals
Assert.True(copy.Remove("first"))
Assert.False(copy.Contains("first"))
Assert.Equal(3, copy.Count())
[<Fact>]
let ``removing all inner keys deletes the outer key`` () =
let copy = _TestData.uniquevals
Assert.True(copy.Remove("first", 1))
Assert.True(copy.Remove("first", 2))
Assert.True(copy.Remove("first", 3))
Assert.False(copy.Contains("first"))
[<Fact>]
let ``returns false on missing inner key`` () =
Assert.False(_TestData.uniquevals.Remove("first", 0))
[<Fact>]
let ``returns false on missing outer key`` () =
Assert.False(_TestData.uniquevals.Remove("missing"))

1
lib/TweetTest.Unit/TweetTest.Unit.fsproj
View File

@ -67,6 +67,7 @@
<Compile Include="Core\TestTwitterUtils.fs" />
<Compile Include="Data\TestInjectedHTML.fs" />
<Compile Include="Data\TestResult.fs" />
<Compile Include="Data\TestTwoKeyDictionary.fs" />
</ItemGroup>
<ItemGroup>
<Reference Include="Microsoft.VisualStudio.CodeCoverage.Shim">

217
tests/Data/TestTwoKeyDictionary.cs
View File

@ -1,217 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using TweetDuck.Data;
namespace UnitTests.Data{
[TestClass]
public class TestTwoKeyDictionary{
private static TwoKeyDictionary<string, int, string> CreateDict(){
TwoKeyDictionary<string, int, string> dict = new TwoKeyDictionary<string, int, string>();
dict.Add("aaa", 0, "x");
dict.Add("aaa", 1, "y");
dict.Add("aaa", 2, "z");
dict.Add("bbb", 0, "test 1");
dict.Add("bbb", 10, "test 2");
dict.Add("bbb", 20, "test 3");
dict.Add("bbb", 30, "test 4");
dict.Add("ccc", -5, "");
dict.Add("", 0, "");
return dict;
}
[TestMethod]
public void TestAdd(){
CreateDict();
}
[TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void TestAddDuplicate(){
var dict = new TwoKeyDictionary<string, int, string>();
dict.Add("aaa", 0, "test");
dict.Add("aaa", 0, "oops");
}
[TestMethod]
public void TestAccessor(){
var dict = CreateDict();
// get
Assert.AreEqual("x", dict["aaa", 0]);
Assert.AreEqual("y", dict["aaa", 1]);
Assert.AreEqual("z", dict["aaa", 2]);
Assert.AreEqual("test 3", dict["bbb", 20]);
Assert.AreEqual("", dict["ccc", -5]);
Assert.AreEqual("", dict["", 0]);
// set
dict["aaa", 0] = "replaced entry";
Assert.AreEqual("replaced entry", dict["aaa", 0]);
dict["aaa", 3] = "new entry";
Assert.AreEqual("new entry", dict["aaa", 3]);
dict["xxxxx", 150] = "new key and entry";
Assert.AreEqual("new key and entry", dict["xxxxx", 150]);
}
[TestMethod]
public void TestInnerValues(){
CollectionAssert.AreEqual(new string[]{
"x",
"y",
"z",
"test 1",
"test 2",
"test 3",
"test 4",
"",
""
}, CreateDict().InnerValues.ToList());
}
[TestMethod]
[ExpectedException(typeof(KeyNotFoundException))]
public void TestAccessorMissingKey1(){
var _ = CreateDict()["missing", 0];
}
[TestMethod]
[ExpectedException(typeof(KeyNotFoundException))]
public void TestAccessorMissingKey2(){
var _ = CreateDict()["aaa", 3];
}
[TestMethod]
public void TestClear(){
var dict = CreateDict();
Assert.IsTrue(dict.Contains("bbb"));
dict.Clear("bbb");
Assert.IsTrue(dict.Contains("bbb"));
Assert.IsTrue(dict.Contains(""));
dict.Clear("");
Assert.IsTrue(dict.Contains(""));
Assert.IsTrue(dict.Contains("aaa"));
Assert.IsTrue(dict.Contains("ccc"));
dict.Clear();
Assert.IsFalse(dict.Contains("aaa"));
Assert.IsFalse(dict.Contains("ccc"));
}
[TestMethod]
[ExpectedException(typeof(KeyNotFoundException))]
public void TestClearMissingKey(){
CreateDict().Clear("missing");
}
[TestMethod]
public void TestContains(){
var dict = CreateDict();
// positive
Assert.IsTrue(dict.Contains("aaa"));
Assert.IsTrue(dict.Contains("aaa", 0));
Assert.IsTrue(dict.Contains("aaa", 1));
Assert.IsTrue(dict.Contains("aaa", 2));
Assert.IsTrue(dict.Contains("ccc"));
Assert.IsTrue(dict.Contains("ccc", -5));
Assert.IsTrue(dict.Contains(""));
Assert.IsTrue(dict.Contains("", 0));
// negative
Assert.IsFalse(dict.Contains("missing"));
Assert.IsFalse(dict.Contains("missing", 999));
Assert.IsFalse(dict.Contains("aaa", 3));
Assert.IsFalse(dict.Contains("", -1));
}
[TestMethod]
public void TestCount(){
var dict = CreateDict();
Assert.AreEqual(9, dict.Count());
Assert.AreEqual(3, dict.Count("aaa"));
Assert.AreEqual(4, dict.Count("bbb"));
Assert.AreEqual(1, dict.Count("ccc"));
Assert.AreEqual(1, dict.Count(""));
}
[TestMethod]
[ExpectedException(typeof(KeyNotFoundException))]
public void TestCountMissingKey(){
CreateDict().Count("missing");
}
[TestMethod]
public void TestRemove(){
var dict = CreateDict();
// negative
Assert.IsFalse(dict.Remove("missing"));
Assert.IsFalse(dict.Remove("aaa", 3));
// positive
Assert.IsTrue(dict.Contains("aaa"));
Assert.IsTrue(dict.Remove("aaa"));
Assert.IsFalse(dict.Contains("aaa"));
Assert.IsTrue(dict.Contains("bbb", 10));
Assert.IsTrue(dict.Remove("bbb", 10));
Assert.IsFalse(dict.Contains("bbb", 10));
Assert.IsTrue(dict.Contains("bbb"));
Assert.IsTrue(dict.Contains("bbb", 20));
Assert.IsTrue(dict.Remove("bbb", 0));
Assert.IsTrue(dict.Remove("bbb", 20));
Assert.IsTrue(dict.Remove("bbb", 30));
Assert.IsFalse(dict.Contains("bbb"));
Assert.IsTrue(dict.Contains(""));
Assert.IsTrue(dict.Remove("", 0));
Assert.IsFalse(dict.Contains(""));
}
[TestMethod]
public void TestTryGetValue(){
var dict = CreateDict();
string val;
// positive
Assert.IsTrue(dict.TryGetValue("bbb", 10, out val));
Assert.AreEqual("test 2", val);
Assert.IsTrue(dict.TryGetValue("ccc", -5, out val));
Assert.AreEqual("", val);
Assert.IsTrue(dict.TryGetValue("", 0, out val));
Assert.AreEqual("", val);
// negative
Assert.IsFalse(dict.TryGetValue("ccc", -50, out val));
Assert.IsFalse(dict.TryGetValue("", 1, out val));
Assert.IsFalse(dict.TryGetValue("missing", 0, out val));
}
}
}

1
tests/UnitTests.csproj
View File

@ -47,7 +47,6 @@
<Compile Include="Data\TestCombinedFileStream.cs" />
<Compile Include="Data\TestCommandLineArgs.cs" />
<Compile Include="Data\TestFileSerializer.cs" />
<Compile Include="Data\TestTwoKeyDictionary.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="UnitTestIO.cs" />
</ItemGroup>