1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
using System;
using NUnit.Framework;
namespace Xamarin.Forms.Core.UnitTests
{
[TestFixture]
public class CommandTests : BaseTestFixture
{
[Test]
public void Constructor ()
{
var cmd = new Command (() => { });
Assert.True (cmd.CanExecute (null));
}
[Test]
public void ThrowsWithNullConstructor ()
{
Assert.Throws<ArgumentNullException> (() => new Command ((Action)null));
}
[Test]
public void ThrowsWithNullParameterizedConstructor ()
{
Assert.Throws<ArgumentNullException> (() => new Command ((Action<object>)null));
}
[Test]
public void ThrowsWithNullCanExecute ()
{
Assert.Throws<ArgumentNullException> (() => new Command (() => { }, null));
}
[Test]
public void ThrowsWithNullParameterizedCanExecute ()
{
Assert.Throws<ArgumentNullException> (() => new Command (o => { }, null));
}
[Test]
public void ThrowsWithNullExecuteValidCanExecute ()
{
Assert.Throws<ArgumentNullException> (() => new Command (null, () => true));
}
[Test]
public void Execute ()
{
bool executed = false;
var cmd = new Command (() => executed = true);
cmd.Execute (null);
Assert.True (executed);
}
[Test]
public void ExecuteParameterized ()
{
object executed = null;
var cmd = new Command (o => executed = o);
var expected = new object ();
cmd.Execute (expected);
Assert.AreEqual (expected, executed);
}
[Test]
public void ExecuteWithCanExecute ()
{
bool executed = false;
var cmd = new Command (() => executed = true, () => true);
cmd.Execute (null);
Assert.True (executed);
}
[Test]
public void CanExecute ([Values (true, false)] bool expected)
{
bool canExecuteRan = false;
var cmd = new Command (() => { }, () => {
canExecuteRan = true;
return expected;
});
Assert.AreEqual(expected, cmd.CanExecute (null));
Assert.True (canExecuteRan);
}
[Test]
public void ChangeCanExecute ()
{
bool signaled = false;
var cmd = new Command (() => { });
cmd.CanExecuteChanged += (sender, args) => signaled = true;
cmd.ChangeCanExecute ();
Assert.True (signaled);
}
[Test]
public void GenericThrowsWithNullExecute ()
{
Assert.Throws<ArgumentNullException> (() => new Command<string> (null));
}
[Test]
public void GenericThrowsWithNullExecuteAndCanExecuteValid ()
{
Assert.Throws<ArgumentNullException> (() => new Command<string> (null, s => true));
}
[Test]
public void GenericThrowsWithValidExecuteAndCanExecuteNull ()
{
Assert.Throws<ArgumentNullException> (() => new Command<string> (s => { }, null));
}
[Test]
public void GenericExecute ()
{
string result = null;
var cmd = new Command<string> (s => result = s);
cmd.Execute ("Foo");
Assert.AreEqual ("Foo", result);
}
[Test]
public void GenericExecuteWithCanExecute ()
{
string result = null;
var cmd = new Command<string> (s => result = s, s => true);
cmd.Execute ("Foo");
Assert.AreEqual ("Foo", result);
}
[Test]
public void GenericCanExecute ([Values (true, false)] bool expected)
{
string result = null;
var cmd = new Command<string> (s => { }, s => {
result = s;
return expected;
});
Assert.AreEqual (expected, cmd.CanExecute ("Foo"));
Assert.AreEqual ("Foo", result);
}
}
}
|
