public void TestKeyComparer_OrderBy_NullKeyComparer_Throws()
{
Func <int, int> keySelector = i => i;
Comparer <int> keyComparer = null;
KeyComparer <int> .OrderBy <int>(keySelector, keyComparer);
}
public void RetrieveUserGroups(UserModel user)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
if (userMapper.AreGroupsLoaded(user))
{
return;
}
user.Groups.EnableSync();
Task.Factory.StartNew(() =>
{
user.Groups.Clear();
var groups = repository.GetUserGroups(user.Name);
var groupModels = groups.Select(g => groupMapper.GetModel(g, includeDummy: false));
var modelComparer = KeyComparer <GroupModel> .OrderBy(m => m.Name);
foreach (GroupModel model in groupModels)
{
int index = user.Groups.ToSublist().UpperBound(model, modelComparer);
user.Groups.Insert(index, model);
}
}).ContinueWith(
t => onErrorOccurred(t.Exception),
CancellationToken.None,
TaskContinuationOptions.OnlyOnFaulted,
TaskScheduler.FromCurrentSynchronizationContext()
);
}
public void TestKeyComparer_OrderBy_WithComparer_NullKeySelector_Throws()
{
Func <int, int> keySelector = null;
Comparer <int> keyComparer = Comparer <int> .Default;
KeyComparer <int> .OrderBy <int>(keySelector, keyComparer);
}
public void RetrieveUserProperties(UserModel user)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
user.Properties.EnableSync();
Task.Factory.StartNew(() =>
{
user.Properties.Clear();
var properties = repository.GetUserProperties(user.Name);
var models = properties.Select(p => propertyMapper.GetModel(p));
var modelComparer = KeyComparer <PropertyModel> .OrderBy(p => p.Name);
foreach (PropertyModel model in models)
{
int index = user.Properties.ToSublist().UpperBound(model, modelComparer);
user.Properties.Insert(index, model);
}
}).ContinueWith(
t => onErrorOccurred(t.Exception),
CancellationToken.None,
TaskContinuationOptions.OnlyOnFaulted,
TaskScheduler.FromCurrentSynchronizationContext()
);
}
public void RetrieveGroupMembers(GroupModel group)
{
if (group == null)
{
throw new ArgumentNullException("group");
}
if (groupMapper.AreUsersLoaded(group))
{
return;
}
group.Users.EnableSync();
Task.Factory.StartNew(() =>
{
group.Users.Clear();
var users = repository.GetGroupMembers(group.Name);
var userModels = users.Select(u => userMapper.GetModel(u, includeDummy: false));
var modelComparer = KeyComparer <UserModel> .OrderBy(m => m.FullName);
foreach (UserModel model in userModels)
{
int index = group.Users.ToSublist().UpperBound(model, modelComparer);
group.Users.Insert(index, model);
}
}).ContinueWith(
t => onErrorOccurred(t.Exception),
CancellationToken.None,
TaskContinuationOptions.OnlyOnFaulted,
TaskScheduler.FromCurrentSynchronizationContext()
);
}
public void Search(string searchTerm)
{
if (repository == null)
{
throw new InvalidOperationException("You must share the connection with the model before searching.");
}
if (Group == null)
{
throw new InvalidOperationException("You must set the group before searching.");
}
if (String.IsNullOrWhiteSpace(searchTerm))
{
return;
}
if (searchTokenSource != null)
{
searchTokenSource.Cancel();
}
searchTokenSource = new CancellationTokenSource();
searchTask = searchTask.ContinueWith(
t => { IsSearching = true; },
searchTokenSource.Token,
TaskContinuationOptions.None,
TaskScheduler.FromCurrentSynchronizationContext()
).ContinueWith(t =>
{
var searchResults = repository.GetUsers(searchTerm, includeGroups: true);
return(searchResults);
}, searchTokenSource.Token).ContinueWith(t =>
{
CancellationToken token = searchTokenSource.Token;
SearchResults.Clear();
Group group = repository.GetGroup(Group.Name);
var searchResults = t.Result;
var models = searchResults.Select(m => userMapper.GetMemberModel(group.DistinguishedName, m));
var modelComparer = KeyComparer <GroupMemberModel> .OrderBy(m => m.FullName).ThenBy(m => m.Name);
foreach (var model in models)
{
token.ThrowIfCancellationRequested();
int index = SearchResults.ToSublist().UpperBound(model, modelComparer);
SearchResults.Insert(index, model);
}
}, searchTokenSource.Token, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Default);
searchTask.ContinueWith(
t => onErrorOccurred(t.Exception),
CancellationToken.None,
TaskContinuationOptions.OnlyOnFaulted,
TaskScheduler.FromCurrentSynchronizationContext()
);
searchTask.ContinueWith(
t => { IsSearching = false; },
searchTokenSource.Token,
TaskContinuationOptions.None,
TaskScheduler.FromCurrentSynchronizationContext()
);
}
public void TestKeyComparer_Explicit_NonGeneric()
{
IComparer comparer = KeyComparer <int> .OrderBy(i => i).Untyped();
int result = comparer.Compare(1, 2);
Assert.IsTrue(result < 0, "Failed to compare values explicitly.");
}
public void TestKeyComparer_SortStringsByLength()
{
Random random = new Random();
string[] names = { "Bob", "George", "Mary", "Jessica", "David" };
IComparer <string> comparer = KeyComparer <string> .OrderBy(item => item.Length);
Array.Sort(names, comparer);
string[] expected = { "Bob", "Mary", "David", "George", "Jessica" };
CollectionAssert.AreEqual(expected, names, "The names were not sorted by length.");
}
public void RetrieveUsers(string searchTerm)
{
if (repository == null)
{
throw new InvalidOperationException("You must connect to AD before querying the users.");
}
AreGroupsDisplayed = false;
AreUsersDisplayed = true;
if (tokenSource != null)
{
tokenSource.Cancel();
}
tokenSource = new CancellationTokenSource();
userTask = userTask.ContinueWith(
t => { IsSearching = true; },
tokenSource.Token,
TaskContinuationOptions.None,
TaskScheduler.FromCurrentSynchronizationContext()
).ContinueWith(t =>
{
CancellationToken token = tokenSource.Token;
Users.Clear();
var users = repository.GetUsers(searchTerm);
var models = users.Select(u => userMapper.GetModel(u, includeDummy: true));
var modelComparer = KeyComparer <UserModel> .OrderBy(u => u.FullName);
foreach (var model in models)
{
token.ThrowIfCancellationRequested();
int index = Users.ToSublist().UpperBound(model, modelComparer);
Users.Insert(index, model);
}
}, tokenSource.Token);
userTask.ContinueWith(
t => onErrorOccurred(t.Exception),
CancellationToken.None,
TaskContinuationOptions.OnlyOnFaulted,
TaskScheduler.FromCurrentSynchronizationContext()
);
userTask.ContinueWith(
t => { IsSearching = false; },
tokenSource.Token,
TaskContinuationOptions.None,
TaskScheduler.FromCurrentSynchronizationContext()
);
}
public void TestKeyComparer_OrderBy_WithKeyComparison()
{
// build a week, starting on a Sunday
DateTime firstDate = new DateTime(2013, 1, 6);
DateTime[] week = new DateTime[]
{
new DateTime(2013, 1, 6),
new DateTime(2013, 1, 7),
new DateTime(2013, 1, 8),
new DateTime(2013, 1, 9),
new DateTime(2013, 1, 10),
new DateTime(2013, 1, 11),
new DateTime(2013, 1, 12),
};
// force Mondays to come first!
IComparer <DayOfWeek> dayComparer = NullComparer <DayOfWeek> .Default.ThenBy(day => (DayOfWeek)((int)(day + 6) % 7));
Array.Sort(week, KeyComparer <DateTime> .OrderBy(d => d.DayOfWeek, dayComparer.Compare));
Assert.AreEqual(firstDate, week[week.Length - 1], "Sunday did not get moved to the end of the week.");
}
