public void TestIndexerSet()
{
var list = new List<string> { "aaa", "bbb", "ccc" };
var set = new ObservableList<string>(list) { [1] = "ddd" };
Assert.AreEqual(set.Count, 3);
Assert.That(set.Contains("aaa"));
Assert.That(set.Contains("ddd"));
Assert.That(set.Contains("ccc"));
}
void onSelectedItemChanged(object sender, SelectionChangeEventArgs e)
{
ProjectItem pi = e.NewValue as ProjectItem;
if (pi != null)
{
if (!openedItems.Contains(pi))
{
openedItems.AddElement(pi);
saveOpenedItemsInUserConfig();
}
}
this.SelectedItem = pi;
UserConfig.Set("SelectedProjItems", SelectedItem?.AbsolutePath);
}
/// <summary>
/// This method is used to get the Target Application
/// </summary>
/// <returns></returns>
private ObservableList <ConvertableTargetApplicationDetails> GetTargetApplication()
{
ObservableList <ConvertableTargetApplicationDetails> lstTA = new ObservableList <ConvertableTargetApplicationDetails>();
// fetching list of selected convertible activities from the first grid
if (mWizard.ConversionType == ActionsConversionWizard.eActionConversionType.SingleBusinessFlow)
{
foreach (var targetBase in mWizard.Context.BusinessFlow.TargetApplications)
{
if (!TargetAppList.Contains(targetBase.ItemName))
{
lstTA.Add(new ConvertableTargetApplicationDetails()
{
SourceTargetApplicationName = targetBase.ItemName, TargetTargetApplicationName = targetBase.ItemName
});
TargetAppList.Add(targetBase.ItemName);
}
}
}
else
{
foreach (var targetBase in mWizard.ListOfBusinessFlow.Where(x => x.IsSelected).SelectMany(y => y.BusinessFlow.TargetApplications))
{
if (!TargetAppList.Contains(targetBase.ItemName))
{
lstTA.Add(new ConvertableTargetApplicationDetails()
{
SourceTargetApplicationName = targetBase.ItemName, TargetTargetApplicationName = targetBase.ItemName
});
TargetAppList.Add(targetBase.ItemName);
}
}
}
return(lstTA);
}
public void ReturnRandomItem()
{
var testList = new ObservableList <int>
{
1,
2,
3,
4,
5
};
var randomItemFromList = testList.Random();
Assert.IsTrue(testList.Contains(randomItemFromList));
}
private void Initialize(ObservableList <IImageSet> imageSets)
{
if (imageSets.Count == 0)
{
return;
}
foreach (IImageSet imageSet in imageSets)
{
_tree.Items.Add(new DisplaySetTreeGroupItem(imageSet, _bingding));
if (!_imageSets.Contains(imageSet))
{
_imageSets.Add(imageSet);
}
}
}
List <ITreeViewItem> ITreeViewItem.Childrens()
{
List <ITreeViewItem> Childrens = new List <ITreeViewItem>();
ObservableList <BusinessFlow> BFs;
if (Folder == "Recently Used")
{
// Since Recently used is per user we keep temp file in the solution folder using MRU class
BFs = new ObservableList <BusinessFlow>();
string[] BizFlowsFile = App.UserProfile.Solution.RecentlyUsedBusinessFlows.getList();
foreach (string BFfilename in BizFlowsFile)
{
// DO NOT load from file - need to search or get from db repo... so it will all be in sync wherever ths BF is used
//BusinessFlow BF = App.LocalRepository.GetBusinessFlow(BFfilename);
BusinessFlow BF = App.LocalRepository.GetItemByFileName <BusinessFlow>(typeof(BusinessFlow), BFfilename);
if (BF != null && BFs.Contains(BF) == false)
{
BFs.Add(BF);
}
}
}
else
{
if (WorkSpace.Instance.BetaFeatures.BFUseSolutionRepositry)
{
BFs = mRepositoryFolder.GetFolderItems();
AddsubFolders(mRepositoryFolder, Childrens);
}
else
{
BFs = App.LocalRepository.GetSolutionBusinessFlows(specificFolderPath: Path);
AddsubFolders(Path, Childrens);
}
}
//Add Business Flows to tree children
foreach (BusinessFlow BF in BFs)
{
BusinessFlowTreeItem BFTI = new BusinessFlowTreeItem(mViewMode);
BFTI.BusinessFlow = BF;
Childrens.Add(BFTI);
}
return(Childrens);
}
private void TestWithRandomOperations(Func <IActiveList <int>, IActiveSet <int> > operation)
{
RandomGenerator.ResetRandomGenerator();
var list = new ObservableList <int>();
foreach (var value in RandomGenerator.GenerateRandomIntegerList(100, 0, 50))
{
list.Add(list.Count, value);
}
var set = operation.Invoke(list);
IActiveValue <bool> sut;
if (set is IActiveSetList <int> setList)
{
sut = setList.ActiveSetContains(25);
}
else
{
sut = (set as IActiveLookup <int, int>).ActiveSetContains(25);
}
foreach (var value in Enumerable.Range(0, 1000))
{
switch (list.Count > 0 ? RandomGenerator.GenerateRandomInteger(0, 4) : 0)
{
case 0:
list.Add(RandomGenerator.GenerateRandomInteger(0, list.Count), RandomGenerator.GenerateRandomInteger(0, 50));
break;
case 1:
list.Remove(RandomGenerator.GenerateRandomInteger(0, list.Count));
break;
case 2:
list.Replace(RandomGenerator.GenerateRandomInteger(0, list.Count), RandomGenerator.GenerateRandomInteger(0, 50));
break;
case 3:
list.Move(RandomGenerator.GenerateRandomInteger(0, list.Count), RandomGenerator.GenerateRandomInteger(0, list.Count));
break;
}
Assert.Equal(sut.Value, list.Contains(25));
}
}
public OuterNavViewModel(IReadOnlyList <INavItem> navItems, INavItem selectedNavItem = null)
{
if (navItems == null)
{
throw new ArgumentNullException("navItems");
}
_navItems = new ObservableList <INavItem>(navItems);
if (selectedNavItem != null)
{
if (!_navItems.Contains(selectedNavItem))
{
throw new Exception("selectedNavItem is not contained in navItems");
}
_selectedNavItem = selectedNavItem;
}
}
public void HandleMessage(Message message)
{
var messageHash = message.Hash;
T value = (T)message.Body.Value;
var predecessors = message.Predecessors;
if (!_predecessors.Contains(messageHash))
{
_candidates.Add(new Candidate <T>(messageHash, value));
}
var newPredecessors = predecessors.Except(_predecessors);
_candidates.RemoveAll(c => newPredecessors.Contains(c.MessageHash));
_predecessors.AddRange(newPredecessors);
}
private static void CreateNewTestInstances(BusinessFlow businessFlow, ObservableList <ActivitiesGroup> existingActivitiesGroups, QCTestSet testSet, ObservableList <ExternalItemFieldBase> testInstancesFields)
{
int counter = 1;
foreach (ActivitiesGroup ag in businessFlow.ActivitiesGroups)
{
if (existingActivitiesGroups.Contains(ag) == false && string.IsNullOrEmpty(ag.ExternalID) == false && ImportFromQCRest.GetQCTest(ag.ExternalID) != null)
{
QCTestInstance testInstance = new QCTestInstance
{
TestId = ag.ExternalID,
CycleId = testSet.Id,
TestOrder = counter++.ToString(),
};
//set item fields for test instances
foreach (ExternalItemFieldBase field in testInstancesFields)
{
if ((field.ToUpdate || field.Mandatory) && (!(field.ExternalID == "test-id") && !(field.ExternalID == "cycle-id")))
{
if (string.IsNullOrEmpty(field.ExternalID) == false && field.SelectedValue != "NA")
{
testInstance.ElementsField[field.ExternalID] = field.SelectedValue;
}
else
{
try { testInstance.ElementsField[field.ID] = "NA"; }
catch { }
}
}
}
testInstance.ElementsField["subtype-id"] = "hp.qc.test-instance.MANUAL";
QCItem item = ConvertObjectValuesToQCItem(testInstance, ResourceType.TEST_CYCLE);
ALMResponseData response = QCRestAPIConnect.CreateNewEntity(ResourceType.TEST_CYCLE, item);
if (response.IsSucceed) // # Currently bug in HPE failing the test instance creation despite it working.
{
//QCTestInstance testInstanceCreated = QCRestAPIConnect.QcRestClient.GetTestInstanceDetails(response.IdCreated);
ag.ExternalID2 = response.IdCreated;//the test case instance ID in the test set- used for exporting the execution details
}
}
}
}
/// <summary>
/// Adds a single item to this node.
/// </summary>
protected virtual bool AddItem(T item)
{
if (!_specification.Test(item).Success)
{
return(false);
}
if (!AddItemToChildren(item))
{
if (!_items.Contains(item))
{
_items.Add(item);
}
return(true);
}
return(false);
}
private void button3_Click(object sender, EventArgs e)
{
if (list.Contains(textBox1.Text))
{
MessageBox.Show("'" + textBox1.Text + "'" + " is in the list");
}
else if (list.IsEmpty)
{
MessageBox.Show("There is no items in the list");
}
else if (textBox1.Text == null || textBox1.Text == "")
{
MessageBox.Show("Please enter an item to check");
}
else
{
MessageBox.Show("There is no " + "'" + textBox1.Text + "'" + " in the list");
}
}
private void ShowTags()
{
// We create a temp list for selection and mark the selected if exist already
list = new ObservableList <SelectedTag>();
foreach (RepositoryItemTag t in WorkSpace.Instance.Solution.Tags)
{
SelectedTag st = new SelectedTag();
st.Name = t.Name;
st.Description = t.Description;
st.GUID = t.Guid;
if (mTags.Contains(t.Guid))
{
st.Selected = true;
}
list.Add(st);
}
TagsGrid.DataSourceList = list;
}
private void GlobalVariables_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
{
//update list
foreach (VariableString var in WorkSpace.Instance.Solution.Variables.Where(x => x is VariableString).ToList())
{
if (mGlobalVariablesList.Contains(var) == false)
{
mGlobalVariablesList.Add(var);
}
}
for (int indx = 0; indx < mGlobalVariablesList.Count; indx++)
{
if (WorkSpace.Instance.Solution.Variables.Contains(mGlobalVariablesList[indx]) == false)
{
mGlobalVariablesList.Remove(mGlobalVariablesList[indx]);
indx--;
}
}
SetValueControlsData();
}
private void btn_containsint_Click(object sender, EventArgs e)
{
int value = 0;
string message = "";
if (true == int.TryParse(tbx_containsint.Text, out value))
{
if (true == intList.Contains(value))
{
message += value + " is in the list.";
}
else
{
message += value + " is NOT in the list.";
}
}
else
{
message += "Not a valid integer provided to check in list.";
}
MessageBox.Show(message);
}
public void RandomlyChangeActiveValue()
{
RandomGenerator.ResetRandomGenerator();
var list = new ObservableList <int>();
foreach (var value in Enumerable.Range(0, 100))
{
list.Add(list.Count, RandomGenerator.GenerateRandomInteger());
}
var compareValue = new ActiveValue <int>();
var sut = list.ActiveContains(compareValue);
foreach (var value in Enumerable.Range(0, 100))
{
compareValue.Value = RandomGenerator.GenerateRandomInteger(-10, 110);
Assert.Equal(list.Contains(compareValue.Value), sut.Value);
}
}
public static void RemoveAtTest()
{
Guid[] anArray = { Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid() };
ObservableList <Guid> col0 = new ObservableList <Guid>((IEnumerable <Guid>)anArray);
ObservableList <Guid> col1 = new ObservableList <Guid>((IEnumerable <Guid>)anArray);
ObservableList <Guid> col2 = new ObservableList <Guid>((IEnumerable <Guid>)anArray);
col0.RemoveAt(0);
string collectionString = "";
foreach (var item in col1)
{
collectionString += item + ", ";
}
Assert.False(col0.Contains(anArray[0]), "Collection0 should no longer contain the item: " + anArray[0] + " Collection: " + collectionString);
col1.RemoveAt(1);
collectionString = "";
foreach (var item in col1)
{
collectionString += item + ", ";
}
Assert.False(col1.Contains(anArray[1]), "Collection1 should no longer contain the item: " + anArray[1] + " Collection: " + collectionString);
col2.RemoveAt(2);
collectionString = "";
foreach (var item in col2)
{
collectionString += item + ", ";
}
Assert.False(col2.Contains(anArray[2]), "Collection2 should no longer contain the item: " + anArray[2] + " Collection: " + collectionString);
string[] anArrayString = { "one", "two", "three", "four" };
ObservableList <string> col = new ObservableList <string>(anArrayString);
CollectionAndPropertyChangedTester helper = new CollectionAndPropertyChangedTester();
helper.RemoveItemAtTest(col, 1);
}
public void UnitTest18(ObservableList <int> list)
{
// ARRANGE
EnvironmentSettings.AlwaysSuppressCurrentSynchronizationContext = true;
// ACT
list.RemoveRange(3);
Assert.False(list.Contains(4));
Assert.False(list.Contains(23));
list.Undo();
Assert.True(list.Contains(4));
Assert.True(list.Contains(23));
list.Redo();
// ASSERT
Assert.False(list.Contains(4));
Assert.False(list.Contains(23));
}
public void UnitTest3(ObservableList <int> list)
{
// ARRANGE
EnvironmentSettings.AlwaysSuppressCurrentSynchronizationContext = true;
list.AddRange(new[] { 6, 5, 2 });
Assert.True(list.Contains(6));
Assert.True(list.Contains(5));
Assert.True(list.Contains(2));
// ACT
list.Undo();
// ASSERT
Assert.False(list.Contains(6));
Assert.False(list.Contains(5));
Assert.False(list.Contains(2));
Assert.Equal(
5,
list.Count);
}
public static bool ExportBusinessFlowToQC(BusinessFlow businessFlow, TestSet mappedTestSet, string uploadPath, ObservableList <ExternalItemFieldBase> testSetFields, ref string result)
{
TestSet testSet;
ObservableList <ActivitiesGroup> existingActivitiesGroups = new ObservableList <ActivitiesGroup>();
try
{
if (mappedTestSet == null)
{
//##create new Test Set in QC
TestSetFactory TestSetF = (TestSetFactory)mTDConn.TestSetFactory;
testSet = (TestSet)TestSetF.AddItem(System.DBNull.Value);
//set the upload path
TestSetTreeManager treeM = (TestSetTreeManager)mTDConn.TestSetTreeManager;
ISysTreeNode testSetParentFolder = (ISysTreeNode)treeM.get_NodeByPath(uploadPath);
testSet.TestSetFolder = testSetParentFolder.NodeID;
}
else
{
//##update existing test set
//testSet = mappedTestSet;
testSet = ImportFromQC.GetQCTestSet(mappedTestSet.ID.ToString());
TSTestFactory testsF = (TSTestFactory)testSet.TSTestFactory;
List tsTestsList = testsF.NewList("");
foreach (TSTest tsTest in tsTestsList)
{
ActivitiesGroup ag = businessFlow.ActivitiesGroups.Where(x => (x.ExternalID == tsTest.TestId.ToString() && x.ExternalID2 == tsTest.ID.ToString())).FirstOrDefault();
if (ag == null)
{
testsF.RemoveItem(tsTest.ID);
}
else
{
existingActivitiesGroups.Add(ag);
}
}
}
//set item fields
foreach (ExternalItemFieldBase field in testSetFields)
{
if (field.ToUpdate || field.Mandatory)
{
if (string.IsNullOrEmpty(field.SelectedValue) == false && field.SelectedValue != "NA")
{
testSet[field.ID] = field.SelectedValue;
}
else
{
try { testSet[field.ID] = "NA"; }
catch { }
}
}
}
//post the test set
testSet.Name = businessFlow.Name;
try
{
testSet.Post();
}
catch (Exception ex)
{
if (ex.Message.Contains("The Test Set already exists"))
{
result = "Cannot export " + GingerDicser.GetTermResValue(eTermResKey.BusinessFlow) + "- The Test Set already exists in the selected folder. ";
Reporter.ToLog(eLogLevel.ERROR, result, ex);
return(false);
}
//Searching for the testset in case it was created in ALM although getting exception
TestSetFactory TSetFact = mTDConn.TestSetFactory;
TDFilter tsFilter = TSetFact.Filter;
TestSetTreeManager treeM = (TestSetTreeManager)mTDConn.TestSetTreeManager;
ISysTreeNode testSetParentFolder = (ISysTreeNode)treeM.get_NodeByPath(uploadPath);
try
{
tsFilter["CY_FOLDER_ID"] = "" + testSetParentFolder.NodeID + "";
}
catch (Exception e)
{
tsFilter["CY_FOLDER_ID"] = "\"" + testSetParentFolder.Path.ToString() + "\"";
Reporter.ToLog(eLogLevel.ERROR, $"Method - {MethodBase.GetCurrentMethod().Name}, Error - {e.Message}", e);
}
List TestsetList = TSetFact.NewList(tsFilter.Text);
foreach (TestSet set in TestsetList)
{
if (set.Name == businessFlow.Name)
{
testSet = set;
break;
}
}
}
businessFlow.ExternalID = testSet.ID.ToString();
//Add missing test cases
TSTestFactory testCasesF = testSet.TSTestFactory;
foreach (ActivitiesGroup ag in businessFlow.ActivitiesGroups)
{
if (existingActivitiesGroups.Contains(ag) == false && string.IsNullOrEmpty(ag.ExternalID) == false && ImportFromQC.GetQCTest(ag.ExternalID) != null)
{
TSTest tsTest = testCasesF.AddItem(ag.ExternalID);
if (tsTest != null)
{
ag.ExternalID2 = tsTest.ID;//the test case instance ID in the test set- used for exporting the execution details
}
}
else
{
foreach (ActivityIdentifiers actIdent in ag.ActivitiesIdentifiers)
{
ExportActivityAsTestStep(ImportFromQC.GetQCTest(ag.ExternalID), (Activity)actIdent.IdentifiedActivity);
}
}
}
return(true);
}
catch (Exception ex)
{
result = "Unexpected error occurred- " + ex.Message;
Reporter.ToLog(eLogLevel.ERROR, "Failed to export the " + GingerDicser.GetTermResValue(eTermResKey.BusinessFlow) + " to QC/ALM", ex);
return(false);
}
}
public void TestContains()
{
var list = new List<string> { "aaa", "bbb", "ccc" };
var set = new ObservableList<string>(list);
Assert.That(set.Contains("aaa"));
Assert.That(set.Contains("bbb"));
Assert.That(set.Contains("ccc"));
Assert.That(!set.Contains("ddd"));
}
public bool Optimize()
{
Mouse.OverrideCursor = System.Windows.Input.Cursors.Wait;
mErrorsList.ClearAll();
ShowErros(false);
ColorIndex = 0;
mGherkinScenarioDefinition.ClearAll();
mGherkinSteps.ClearAll();
mTags.ClearAll();
mOptimizedSteps.ClearAll();
OptimizedStepsGrid.DataSourceList = mOptimizedSteps;
var parser = new Parser();
try
{
string txt = GherkinTextEditor.GetText();
TextReader sr = new StringReader(txt);
var gherkinDocument = parser.Parse(sr);
if (gherkinDocument.Feature == null || gherkinDocument.Feature.Children == null)
{
Mouse.OverrideCursor = null;
return(false);
}
foreach (ScenarioDefinition SD in gherkinDocument.Feature.Children)
{
mGherkinScenarioDefinition.Add(new GherkinScenarioDefinition(SD));
}
FeatureName = System.IO.Path.GetFileName(GherkinTextEditor.FileName).Replace(".feature", "");
foreach (var c in gherkinDocument.Comments)
{
WriteTXT("Comments:" + c.Text);
}
foreach (Tag t in gherkinDocument.Feature.Tags)
{
mTags.Add(new GherkinTag(t));
}
mSolTags.ClearAll();
foreach (GherkinTag tag in mTags)
{
Guid guid = GetTagInSolution(tag.Name.Substring(1));
if (guid != Guid.Empty && !mSolTags.Contains(guid))
{
mSolTags.Add(guid);
}
}
foreach (var c in gherkinDocument.Feature.Children)
{
if (c.Keyword == "Scenario" || c.Keyword == "Scenario Outline")
{
WriteTXT("Keyword:" + c.Keyword);
WriteTXT("Name:" + c.Name);
if (c is Scenario)
{
foreach (Tag t in ((Gherkin.Ast.Scenario)c).Tags)
{
mTags.Add(new GherkinTag(t));
Guid guid = GetTagInSolution(t.Name.Substring(1));
if (guid != Guid.Empty && !mSolTags.Contains(guid))
{
mSolTags.Add(guid);
}
}
}
if (c is ScenarioOutline)
{
foreach (Tag t in ((Gherkin.Ast.ScenarioOutline)c).Tags)
{
mTags.Add(new GherkinTag(t));
Guid guid = GetTagInSolution(t.Name.Substring(1));
if (guid != Guid.Empty && !mSolTags.Contains(guid))
{
mSolTags.Add(guid);
}
}
}
}
}
foreach (var c in gherkinDocument.Feature.Children)
{
if (c.Keyword == "Scenario" || c.Keyword == "Scenario Outline")
{
foreach (var step in c.Steps)
{
WriteTXT("Keyword:" + step.Keyword);
WriteTXT("Text:" + step.Text);
GherkinStep GS = new GherkinStep();
GS.Text = step.Text;
GS.Step = step;
mGherkinSteps.Add(GS);
String GherkingActivityName = GherkinGeneral.GetActivityGherkinName(step.Text);
GherkinStep OptimizedStep = SearchStepInOptimizedSteps(GherkingActivityName);
if (OptimizedStep == null)
{
GherkinStep NewOptimizedStep = new GherkinStep();
NewOptimizedStep.Text = GherkingActivityName;
NewOptimizedStep.Counter = 1;
NewOptimizedStep.ColorIndex = ColorIndex;
ColorIndex++;
NewOptimizedStep.AutomationStatus = GetStepAutomationStatus(GherkingActivityName);
GS.AutomationStatus = NewOptimizedStep.AutomationStatus;
mOptimizedSteps.Add(NewOptimizedStep);
}
else
{
OptimizedStep.Counter++;
GS.ColorIndex = OptimizedStep.ColorIndex;
GS.AutomationStatus = OptimizedStep.AutomationStatus;
}
}
}
}
// Warnings - TODO check other possible warnings
// Check Dups Scenario names
var query = mGherkinScenarioDefinition.GroupBy(x => x.Name)
.Where(g => g.Count() > 1)
.Select(y => y.Key)
.ToList();
foreach (var v in query)
{
IEnumerable <GherkinScenarioDefinition> SCS = from x in mGherkinScenarioDefinition where x.Name == v select x;
foreach (GherkinScenarioDefinition sc in SCS)
{
GherkinParserException PE = new GherkinParserException(sc.ScenarioDefintion.Location.Line, sc.ScenarioDefintion.Location.Column, "Duplicate Scenario Name: " + sc.Name);
mErrorsList.Add(PE);
}
}
}
catch (CompositeParserException ex)
{
// we show the errors in the grid + mark in the textEditor
GherkinTextEditor.BackgroundRenderer.Segments.Clear();
foreach (ParserException PE in ex.Errors)
{
mErrorsList.Add(new GherkinParserException(PE));
if (PE.Location.Line > GherkinTextEditor.textEditor.Document.LineCount)
{
continue;
}
var line = GherkinTextEditor.textEditor.Document.GetLineByNumber(PE.Location.Line);
GherkinTextEditor.BackgroundRenderer.Segments.Add(line);
}
}
if (mErrorsList.Count > 0)
{
ShowErros(true);
GherkinTextEditor.Focus();
}
else
{
GherkinTextEditor.BackgroundRenderer.Segments.Clear();
}
ARP.xActivitiesRepositoryGrid.Tags = mSolTags;
SharedActivitiesFrame.Content = ARP;
foreach (GherkinStep gStep in mOptimizedSteps)
{
}
OptimizedStepsGrid.DataSourceList = mOptimizedSteps;
Mouse.OverrideCursor = null;
List <GherkinParserException> Errors = mErrorsList.Where(x => x.ErrorType == GherkinParserException.eErrorType.Error).ToList();
bool result = mOptimizedSteps.Count > 0 && Errors.Count == 0;
return(result);
}
public void UnitTest11(ObservableList <int> list)
{
// ARRANGE
EnvironmentSettings.AlwaysSuppressCurrentSynchronizationContext = true;
list.Add(18);
list.RemoveAt(1);
list.Insert(
3,
5);
list.Clear();
list.Add(7);
// Act & Assert groups
Assert.Single(list);
Assert.Equal(
7,
list[0]);
// Level one
list.Undo();
Assert.Empty(list);
// Level two
list.Undo();
Assert.Equal(
6,
list.Count);
Assert.Equal(
5,
list[3]);
// Level three
list.Undo();
Assert.Equal(
5,
list.Count);
Assert.Equal(
4,
list[3]);
// Level four
list.Undo();
Assert.Equal(
6,
list.Count);
Assert.Equal(
7,
list[1]);
// Level two
list.Undo();
Assert.Equal(
5,
list.Count);
Assert.False(list.Contains(18));
// Redo
list.Redo();
list.Redo();
list.Redo();
list.Redo();
Assert.Empty(list);
}
/// <summary>
/// The event that is raised when the user clicks "Contains?". It sends the user input to the correct method to check the list.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Contains_Click(object sender, EventArgs e)
{
string inputValue = textBox.Text;
observableList.Contains(inputValue);
}
//----------------------------------------------------------------------
public ListView(Screen _screen)
: base(_screen)
{
Columns = new List <ListViewColumn>();
Rows = new ObservableList <ListViewRow>();
Rows.ListCleared += delegate {
SelectedRow = null;
HoveredRow = null;
FocusedRow = null;
mHoveredActionButton = null;
mbIsHoveredActionButtonDown = false;
};
Rows.ListChanged += delegate(object _source, ObservableList <ListViewRow> .ListChangedEventArgs _args)
{
if (!_args.Added)
{
if (_args.Item == SelectedRow)
{
SelectedRow = null;
}
if (_args.Item == HoveredRow)
{
UpdateHoveredRow();
}
if (_args.Item == FocusedRow)
{
FocusedRow = null;
IsDragging = false;
}
}
};
SelectedRow = null;
FocusedRow = null;
HoveredRow = null;
TextColor = Screen.Style.DefaultTextColor;
Padding = Screen.Style.ListViewPadding;
Style = Screen.Style.ListViewStyle;
Scrollbar = new Scrollbar(_screen);
Scrollbar.Parent = this;
ActionButtons = new ObservableList <Button>();
ActionButtons.ListCleared += delegate {
mHoveredActionButton = null;
};
ActionButtons.ListChanged += delegate {
if (mHoveredActionButton != null && !ActionButtons.Contains(mHoveredActionButton))
{
mHoveredActionButton = null;
}
};
UpdateContentSize();
}
public MenuPage()
{
InitializeComponent();
// Project group
mProjectGroup = new ObservableList <HomeMenuItem> {
GroupedLongName = Languages.Global.Str0Project,
GroupedShortName = "P",
};
//mProjectGroup.Add( new HomeMenuItem { Id = MenuItemType.ProjectNew, Title = Languages.Global.Str0New } );
mProjectGroup.Add(new HomeMenuItem {
Id = MenuItemType.ProjectOpen, Title = Languages.Global.Str0Open
});
//mProjectGroup.Add( new HomeMenuItem { Id = MenuItemType.ProjectSave, Title = Languages.Global.Str0Save } );
//mProjectGroup.Add( new HomeMenuItem { Id = MenuItemType.ProjectClose, Title = Languages.Global.Str0Close } );
//mProjectGroup.Add( mProjectSettingsMenu );
mProjectGroup.Add(new HomeMenuItem {
Id = MenuItemType.RecentProjectRequest, Title = Languages.ProjectGlossary.Str0RecentProjects
});
// Options group
var optionMenuItems = new ObservableList <HomeMenuItem> {
GroupedLongName = Languages.Global.Str0Options,
GroupedShortName = "O",
};
mXlatorMenu = new HomeMenuItem {
Id = MenuItemType.TranslatorSelectorRequest, Title = Languages.Global.Str0Translator
};
optionMenuItems.Add(mXlatorMenu);
optionMenuItems.Add(new HomeMenuItem {
Id = MenuItemType.Others, Title = Languages.Global.Str0About
});
mGroupMenuItems.Add(mProjectGroup);
mGroupMenuItems.Add(optionMenuItems);
LvMenu.ItemsSource = mGroupMenuItems;
LvMenu.SelectedItem = mGroupMenuItems[0];
LvMenu.ItemSelected += async(sender, e) => {
if (e.SelectedItem == null)
{
return;
}
var id = ((HomeMenuItem)e.SelectedItem).Id;
// tell MainPage selected MenuItemType
await MessageHub.SendMessageAsync(this, MessageType.MenuNavigate, id);
LvMenu.SelectedItem = null;
};
// subscribe MessageHub event
MessageHub.MessageReceived += (sender, type, data) => {
if (sender == this)
{
return;
}
switch (type)
{
case MessageType.XlatorSelected:
// update Translator menu icon when new Translator selected
if (data is Models.TranslatorSelector ts)
{
mXlatorMenu.Icon = ts.Icon;
}
break;
case MessageType.ProjectClosed:
// hide Project Setting MenuItem when project closed
if (mProjectGroup.Contains(mProjectSaveMenu))
{
mProjectGroup.Remove(mProjectSaveMenu);
}
if (mProjectGroup.Contains(mProjectCloseMenu))
{
mProjectGroup.Remove(mProjectCloseMenu);
}
if (mProjectGroup.Contains(mProjectSettingsMenu))
{
mProjectGroup.Remove(mProjectSettingsMenu);
}
LvMenu.ItemsSource = mGroupMenuItems;
break;
case MessageType.ProjectOpened:
// show Project Setting MenuItem when project opened
if (mProjectGroup.Contains(mProjectSaveMenu) == false)
{
mProjectGroup.Insert(1, mProjectSaveMenu);
}
if (mProjectGroup.Contains(mProjectCloseMenu) == false)
{
mProjectGroup.Insert(2, mProjectCloseMenu);
}
if (mProjectGroup.Contains(mProjectSettingsMenu) == false)
{
mProjectGroup.Insert(3, mProjectSettingsMenu);
}
LvMenu.ItemsSource = mGroupMenuItems;
break;
}
};
}
public bool Contains(T item)
{
return(_list.Contains(item));
}
