public void ShouldEnumerateOnce_WhenAskingForCountMultipleTimes()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
var enumerator = smartList.GetEnumerator();
enumerator.MoveNext();
// Act
var count0 = smartList.Count;
var count1 = smartList.Count;
var count2 = smartList.Count;
// Assert
Assert.Equal(3, count0);
Assert.Equal(3, count1);
Assert.Equal(3, count2);
Assert.True(enumerable.Enumerated);
// Cleanup
enumerator.Dispose();
}
public void ShouldReturnCount_WhenFullyEnumerated()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
var enumerator = smartList.GetEnumerator();
enumerator.MoveNext();
enumerator.MoveNext();
enumerator.MoveNext();
enumerator.MoveNext();
enumerator.MoveNext();
// Act
var count = smartList.Count;
// Assert
Assert.Equal(3, count);
Assert.True(enumerable.Enumerated);
// Cleanup
enumerator.Dispose();
}
public void ShouldReturnCachedValue_WhenAskingEnumeratedIndex()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
yield return("d");
yield return("e");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
var enumerator = smartList.GetEnumerator();
enumerator.MoveNext();
enumerator.MoveNext();
enumerator.MoveNext();
// Act
var second = smartList[1];
// Assert
Assert.Equal("b", second);
Assert.True(enumerable.Enumerated);
Assert.Equal(3, enumerable.NextIndex);
// Cleanup
enumerator.Dispose();
}
public ActionResult DetailsSmartList(string title)
{
ViewBag.Edit_Ability = false;
SmartList list = null; IQueryable <Task> TasksInList = null;
switch (title)
{
case "Today":
list = db.SmartLists.First(l => l.Title == "Today"); ViewBag.list = list;
TasksInList = db.Tasks.Where(t => DbFunctions.TruncateTime(t.Due_Date) == DateTime.Today);
break;
case "All Tasks":
list = db.SmartLists.First(l => l.Title == "All Tasks"); ViewBag.list = list;
TasksInList = db.Tasks as IQueryable <Task>;
break;
case "Important":
list = db.SmartLists.First(l => l.Title == "Important"); ViewBag.list = list;
TasksInList = db.Tasks.Where(t => t.Importance_Level == Importance_Levels.High);
break;
case "Planned":
list = db.SmartLists.First(l => l.Title == "Planned"); ViewBag.list = list;
TasksInList = db.Tasks.Where(t => t.Due_Date != null);
break;
}
TasksInList = list.HideCompleted ? TasksInList.Where(t => t.Complete != true) : TasksInList;
return(View("DetailsList", TasksInList));;
}
public void ShouldContinueEnumerating_WhenAskingIndexPastEnumeratedPart()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
yield return("d");
yield return("e");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
var enumerator = smartList.GetEnumerator();
enumerator.MoveNext();
enumerator.MoveNext();
enumerator.MoveNext();
// Act
var fifth = smartList[4];
// Assert
Assert.Equal("e", fifth);
Assert.True(enumerable.Enumerated);
Assert.Equal(5, enumerable.NextIndex);
// Cleanup
enumerator.Dispose();
}
public IEnumerable <Comment> GetComments(string key)
{
SmartList <Comment> comments = _repository.GetAll(key, CurrentUserId).ToSmartList();
_repository.MarkAsReaded(key, CurrentUserId);
return(comments);
}
public void ShouldContinueEnumerating_WhenAskingSubsequentIndices()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
yield return("d");
yield return("e");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
// Act
var second = smartList[1];
var fourth = smartList[3];
var fifth = smartList[4];
// Assert
Assert.Equal("b", second);
Assert.Equal("d", fourth);
Assert.Equal("e", fifth);
Assert.True(enumerable.Enumerated);
Assert.Equal(5, enumerable.NextIndex);
}
public void ShouldReturnEnumeratorThatCanEnumerateElements_WhenEnumerable()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
// Act
var enumerator = smartList.GetEnumerator();
enumerator.MoveNext();
enumerator.MoveNext();
bool hasNext = enumerator.MoveNext();
string element = enumerator.Current;
bool hasMore = enumerator.MoveNext();
// Assert
Assert.True(hasNext);
Assert.False(hasMore);
Assert.True(enumerable.Enumerated);
Assert.Equal("c", element);
Assert.Equal(3, enumerable.NextIndex);
// Cleanup
enumerator.Dispose();
}
private Global()
{
mainHero = null;
Herous = new SmartList <Hero>();
Enemies = new SmartList <Enemy>();
AllSettings = Settings.Instantiate();
}
void Awake()
{
var md = GameObject.Find("MainData");
mineDatas = md.GetComponent <MainData>().mineDatas;
var gamePart = md.GetComponent <GamePart>();
flipBoard = gamePart.flipBoard;
map = new List2DInt(mineDatas.XSize, mineDatas.YSize, -1);
insideMap = new List2DInt(mineDatas.XSize, mineDatas.YSize, -1);
numberList = new SmartList <HCArea>();
unFlipAreaList = new SmartList <HCArea>();
unFlipAreaInsideList = new SmartList <IndexOfList2D>();
for (int i = 0; i < map.XSize; i++)
{
for (int j = 0; j < map.YSize; j++)
{
insideMap[i, j] = unFlipAreaInsideList.Add(new IndexOfList2D(i, j));
}
}
gamePart.flipAction += ChangeMapByFlip;
GameObject debugWithMap = new GameObject("Map");
debugWithMap.transform.parent = transform;
debugWithMap.AddComponent(typeof(WatchList2DInScene));
debugWithMap.GetComponent <WatchList2DInScene>().list = map;
debugWithMap = new GameObject("InsideMap");
debugWithMap.transform.parent = transform;
debugWithMap.AddComponent(typeof(WatchList2DInScene));
debugWithMap.GetComponent <WatchList2DInScene>().list = insideMap;
}
public void ShouldEnumerateOnlyOnceAndReturnSecondElement_WhenEnumerableAndAskingForSameElement()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
// Act
var second0 = smartList[1];
var second1 = smartList[1];
var second2 = smartList[1];
// Assert
Assert.Equal("b", second0);
Assert.Equal("b", second1);
Assert.Equal("b", second2);
Assert.True(enumerable.Enumerated);
Assert.Equal(2, enumerable.NextIndex);
}
public ActionResult SettingsList(int id = 0)
{
SmartList list = db.SmartLists.Find(id);
if (list == null)
{
return(HttpNotFound());
}
return(View(list));
}
public ActionResult SettingsList(SmartList list)
{
SmartList newlist = db.SmartLists.Find(list.Id);
newlist.HideCompleted = list.HideCompleted;
db.Entry(newlist).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void ShouldWorkWithLinq()
{
// Arrange
IEnumerable <Object> objects = new object[0];
var list = new SmartList <Object>(objects);
// Act
bool result = list.Any(c => c == null);
// Assert
Assert.False(result);
}
public void ShouldNotEnumerateButReturnZero_WhenCollectionIsEmpty()
{
// Arrange
var collection = new CheckingCollection <string>(new string[0]);
var smartList = new SmartList <string>(collection);
// Act
var count = smartList.Count;
// Assert
Assert.Equal(0, count);
Assert.False(collection.Enumerated);
}
public void ShouldNotEnumerateButReturnOne_WhenCollectionIsSingleton()
{
// Arrange
var collection = new CheckingCollection <string>(new [] { "a" });
var smartList = new SmartList <string>(collection);
// Act
var count = smartList.Count;
// Assert
Assert.Equal(1, count);
Assert.False(collection.Enumerated);
}
public void ShouldThrow_WhenIndexIsOutOfBoundOnNonEmptyList()
{
// Arrange
var smartList = new SmartList <string>(new [] { "a", "b", "c" });
// Act
var exception = Record.Exception(() =>
{
var result = smartList[7];
});
// Assert
Assert.IsAssignableFrom <ArgumentOutOfRangeException>(exception);
}
public void ShouldThrow_WhenIndexIsNegativeOnList()
{
// Arrange
var smartList = new SmartList <string>(new string[0]);
// Act
var exception = Record.Exception(() =>
{
var result = smartList[-1];
});
// Assert
Assert.IsAssignableFrom <ArgumentOutOfRangeException>(exception);
}
public void ShouldEnumerateAndReturnZero_WhenEnumerableIsEmpty()
{
// Arrange
IEnumerable <string> Empty()
{
yield break;
}
var enumerable = new CheckingEnumerable <string>(Empty());
var smartList = new SmartList <string>(enumerable);
// Act
var count = smartList.Count;
// Assert
Assert.Equal(0, count);
Assert.True(enumerable.Enumerated);
}
public void ShouldNotEnumerateAndReturnSecondElement_WhenList()
{
// Arrange
var list = new CheckingList <string>(new[]
{
"a",
"b",
"c"
});
var smartList = new SmartList <string>(list);
// Act
var second = smartList[1];
// Assert
Assert.Equal("b", second);
Assert.False(list.Enumerated);
}
public void ShouldEnumerateEnumerableAndReturnOne_WhenEnumerableIsSingleton()
{
// Arrange
IEnumerable <string> Singleton()
{
yield return("a");
}
var enumerable = new CheckingEnumerable <string>(Singleton());
var smartList = new SmartList <string>(enumerable);
// Act
var count = smartList.Count;
// Assert
Assert.Equal(1, count);
Assert.True(enumerable.Enumerated);
}
public void ShouldThrow_WhenIndexIsOutOfBoundOnEmptyEnumerable()
{
// Arrange
IEnumerable <string> Empty()
{
yield break;
}
var smartList = new SmartList <string>(Empty());
// Act
var exception = Record.Exception(() =>
{
var result = smartList[0];
});
// Assert
Assert.IsAssignableFrom <ArgumentOutOfRangeException>(exception);
}
public static SmartList <IField> GetFieldsByAttribute(this IAttribute attribute)
{
var list = new SmartList <IField>();
foreach (var fieldDeclaration in FieldDeclarationNavigator.GetByAttribute(attribute))
{
if (fieldDeclaration.DeclaredElement != null)
{
list.Add(fieldDeclaration.DeclaredElement);
}
}
foreach (var constantDeclaration in ConstantDeclarationNavigator.GetByAttribute(attribute))
{
if (constantDeclaration.DeclaredElement != null)
{
list.Add(constantDeclaration.DeclaredElement);
}
}
return(list);
}
public void ShouldReturnEnumeratorButDoesNotEnumerate_WhenEnumerable()
{
// Arrange
IEnumerable <string> Empty()
{
yield break;
}
var enumerable = new CheckingEnumerable <string>(Empty());
var smartList = new SmartList <string>(enumerable);
// Act
var enumerator = smartList.GetEnumerator();
// Assert
Assert.NotNull(enumerator);
Assert.False(enumerable.Enumerated);
// Cleanup
enumerator.Dispose();
}
public void ShouldEnumerateAndReturnCount_WhenEnumerable()
{
// Arrange
IEnumerable <string> Enumerable()
{
yield return("a");
yield return("b");
yield return("c");
}
var enumerable = new CheckingEnumerable <string>(Enumerable());
var smartList = new SmartList <string>(enumerable);
// Act
var count = smartList.Count;
// Assert
Assert.Equal(3, count);
Assert.True(enumerable.Enumerated);
}
public void ShouldReturnEnumeratorThatImmediatelyReturnsFalse_WhenEmptyEnumerable()
{
// Arrange
IEnumerable <string> Empty()
{
yield break;
}
var enumerable = new CheckingEnumerable <string>(Empty());
var smartList = new SmartList <string>(enumerable);
// Act
var enumerator = smartList.GetEnumerator();
bool hasNext = enumerator.MoveNext();
// Assert
Assert.False(hasNext);
Assert.True(enumerable.Enumerated);
Assert.Equal(0, enumerable.NextIndex);
// Cleanup
enumerator.Dispose();
}
public void ShouldEnumerateAndReturnSecondElement_WhenEnumerable()
{
// Arrange
IEnumerable <string> Singleton()
{
yield return("a");
yield return("b");
yield return("c");
}
var enumerable = new CheckingEnumerable <string>(Singleton());
var smartList = new SmartList <string>(enumerable);
// Act
var second = smartList[1];
// Assert
Assert.Equal("b", second);
Assert.True(enumerable.Enumerated);
Assert.Equal(2, enumerable.NextIndex);
}
public void TestSettingsList()
{
SmartList list = new SmartList {
Title = "Test List", HideCompleted = true
};
db.SmartLists.Add(list);
db.SaveChanges();
SmartList newlist = new SmartList {
Id = list.Id, Title = "Test List", HideCompleted = false
};
controller.SettingsList(newlist);
db = new ToDoContext();
var lists = db.SmartLists.ToList();
newlist = lists.Last(l => l.Id == list.Id);
var result = newlist.HideCompleted != list.HideCompleted;
Assert.IsTrue(result);
//list = db.SmartLists.ToList().Last(l => l.Id == list.Id);
db.Entry(newlist).State = EntityState.Deleted;
db.SaveChanges();
}
/// <summary>
/// conNameTB实现智能列表TextBox的GotFocus事件
/// </summary>
private void conNameTB_GotFocus(object sender, RoutedEventArgs e)
{
try
{
string keyString = comNameTB.Text.Trim();
Guid keyID;
if (keyString.Length == 0)//公司名称为空,检索个人客户
{
keyID = Guid.Empty;
}
else
{
CompanyModel _a = Global.AllCompanies.FirstOrDefault(_func => _func.称 == keyString);
if (_a != null)//找到公司ID,检索单位所属客户
{
keyID = _a.ID;
}
else//找不到公司ID,直接返回
{
return;
}
}
List <SmartInfo> smartList = Global.AllContacts.Where(_func => _func.公司ID == keyID).Select(_func => new SmartInfo()
{
Text = _func.称,
Letter = _func.拼音
}).ToList();
SmartList.TBGotFocus(sender as TextBox, SmartLB, BodyG, true, smartList);
}
catch (Exception)
{
MessageBox.Show("标记(Mark)错误!");
return;
}
}
private void SmartTB_TextChanged(object sender, TextChangedEventArgs e)
{
SmartList.TBChanged(SmartLB);
}
