/// ------------------------------------------------------------------------------------ /// <summary> /// Sets the viewer's current binary mask. Calling this method will also set the /// viewer's current search class type to Binary. /// </summary> /// ------------------------------------------------------------------------------------ public void SetBMask(FeatureMask mask, bool allFeaturesMustMatch) { _bMask = mask; _allFeaturesMustMatch = allFeaturesMustMatch; _srchClassType = SearchClassType.Binary; RefreshEnabledPhones(); }
public void ContainsOneOrMore_WithDiffSizeBits() { var fmask1 = new FeatureMask(100); var fmask2 = new FeatureMask(200); Assert.IsFalse(fmask1.ContainsOneOrMore(fmask2)); }
public void OR() { var fmask1 = new FeatureMask(100); var fmask2 = new FeatureMask(100); fmask1[10] = true; fmask1[20] = true; fmask1[30] = true; var masks = (UInt64[])ReflectionHelper.GetField(fmask1, "m_masks"); Assert.IsTrue(masks[0] > 0); Assert.IsTrue(masks[1] == 0); fmask2[70] = true; fmask2[80] = true; fmask2[90] = true; masks = (UInt64[])ReflectionHelper.GetField(fmask2, "m_masks"); Assert.IsTrue(masks[0] == 0); Assert.IsTrue(masks[1] > 0); fmask1 |= fmask2; Assert.IsTrue(fmask1[10]); Assert.IsTrue(fmask1[20]); Assert.IsTrue(fmask1[30]); Assert.IsTrue(fmask1[70]); Assert.IsTrue(fmask1[80]); Assert.IsTrue(fmask1[90]); }
// "Bit count mismatch: both masks must contain same number of bits.")] public void OR_WithDiffSizeBits() { var fmask1 = new FeatureMask(100); var fmask2 = new FeatureMask(200); Assert.IsNotNull(fmask1 | fmask2); }
// "Bit count mismatch: both masks must contain same number of bits.")] public void ContainsAll_WithDiffSizeBits() { var fmask1 = new FeatureMask(100); var fmask2 = new FeatureMask(200); Assert.IsNotNull(fmask1.ContainsAll(fmask2)); }
public void Clone() { var fmask1 = new FeatureMask(64); fmask1[10] = true; fmask1[20] = true; fmask1[30] = true; fmask1[40] = true; var fmask2 = fmask1.Clone(); Assert.AreEqual(64, fmask2.Size); Assert.AreEqual(1, (int)ReflectionHelper.GetField(fmask2, "m_maskCount")); Assert.IsTrue(fmask2[10]); Assert.IsTrue(fmask2[20]); Assert.IsTrue(fmask2[30]); Assert.IsTrue(fmask2[40]); UInt64 mask = 1; mask <<= 10; mask |= 1; mask <<= 10; mask |= 1; mask <<= 10; mask |= 1; mask <<= 10; var masks = (UInt64[])ReflectionHelper.GetField(fmask2, "m_masks"); Assert.AreEqual(mask, masks[0]); }
public void BitSetting_SingleBit() { var fmask = new FeatureMask(100); var masks = (UInt64[])ReflectionHelper.GetField(fmask, "m_masks"); Assert.AreEqual(0, masks[0]); Assert.AreEqual(0, masks[1]); fmask[0] = true; Assert.AreEqual(1, masks[0]); fmask[0] = false; Assert.AreEqual(0, masks[0]); Int64 expected = 1; expected <<= 9; fmask[9] = true; Assert.AreEqual(expected, masks[0]); expected = 1; expected <<= (90 - 64); fmask[90] = true; Assert.AreEqual(expected, masks[1]); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Handle the user choosing a feature. /// </summary> /// ------------------------------------------------------------------------------------ void HandleFeatureChanged(object sender, FeatureMask newMask) { m_classInfo.Mask = newMask; _textBoxMembers.Text = m_classInfo.FormattedMembersString; m_classInfo.IsDirty = true; UpdateCharacterViewers(); }
/// ------------------------------------------------------------------------------------ public FeatureListViewBase(FeatureMask emptyMask) { _emptyMask = emptyMask; AllowDoubleClickToChangeCheckState = true; var colHdr = new ColumnHeader(); colHdr.Width = kMaxColWidth; _tooltip = new ToolTip(); base.Font = FontHelper.UIFont; _emphasizedFont = FontHelper.MakeFont(FontHelper.UIFont, FontStyle.Bold); CheckBoxes = true; Columns.Add(colHdr); HeaderStyle = ColumnHeaderStyle.None; base.DoubleBuffered = true; LabelEdit = false; MultiSelect = false; HideSelection = false; View = View.List; OwnerDraw = true; Visible = true; }
public void ContainsOneOrMore() { var fmask1 = new FeatureMask(100); var fmask2 = new FeatureMask(100); Assert.IsFalse(fmask1.ContainsOneOrMore(fmask2)); fmask1[45] = true; fmask2[75] = true; Assert.IsFalse(fmask1.ContainsOneOrMore(fmask2)); fmask1[75] = true; fmask2[45] = true; Assert.IsTrue(fmask1.ContainsOneOrMore(fmask2)); fmask1[45] = false; Assert.IsTrue(fmask1.ContainsOneOrMore(fmask2)); fmask1.Clear(); fmask2.Clear(); Assert.IsFalse(fmask1.ContainsOneOrMore(fmask2)); // Overlap by one bit. for (int i = 60; i <= 64; i++) { fmask1[i] = true; } for (int i = 64; i < 70; i++) { fmask2[i] = true; } Assert.IsTrue(fmask1.ContainsOneOrMore(fmask2)); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Sets the viewer's current articulatory masks. Calling this method will also set /// the viewer's current search class type to Articulatory. /// </summary> /// ------------------------------------------------------------------------------------ public void SetAMasks(FeatureMask mask, bool allFeaturesMustMatch) { _aMask = mask; _allFeaturesMustMatch = allFeaturesMustMatch; _srchClassType = SearchClassType.Articulatory; RefreshEnabledPhones(); }
public void NotEqual_WithDiffSizes() { var fmask1 = new FeatureMask(10); var fmask2 = new FeatureMask(20); fmask1[5] = true; fmask2[5] = true; Assert.IsTrue(fmask1 != fmask2); }
public void VerifyToString() { var fmask = new FeatureMask(128); fmask[15] = true; fmask[31] = true; fmask[47] = true; fmask[63] = true; Assert.AreEqual("8000800080008000", fmask.ToString()); }
public void IsEmtpy() { var fmask = new FeatureMask(100); Assert.IsFalse(fmask.IsEmpty); fmask = new FeatureMask(0); Assert.IsTrue(fmask.IsEmpty); fmask = FeatureMask.Empty; Assert.IsTrue(fmask.IsEmpty); }
public void NotEqual_WithNull() { FeatureMask fmask1 = null; FeatureMask fmask2 = null; Assert.IsFalse(fmask1 != fmask2); fmask1 = new FeatureMask(1); Assert.IsTrue(fmask1 != fmask2); fmask1 = null; fmask2 = new FeatureMask(1); Assert.IsTrue(fmask1 != fmask2); }
public void GetFeatureList() { var fmask = new FeatureMask(m_cache.Count); fmask[m_fNames.IndexOf("Onions")] = true; fmask[m_fNames.IndexOf("Ham")] = true; fmask[m_fNames.IndexOf("Cheese")] = true; var list = m_cache.GetFeatureList(fmask).ToArray(); Assert.AreEqual(3, list.Length); Assert.AreEqual("Cheese", list[0]); Assert.AreEqual("Ham", list[1]); Assert.AreEqual("Onions", list[2]); }
public void AreAnyBitsSet() { var fmask = new FeatureMask(100); Assert.IsFalse(fmask.IsAnyBitSet); fmask[45] = true; fmask[75] = true; Assert.IsTrue(fmask[45]); Assert.IsTrue(fmask[75]); Assert.IsTrue(fmask.IsAnyBitSet); fmask[45] = false; fmask[75] = false; Assert.IsFalse(fmask.IsAnyBitSet); }
public void BitSetting_MultipleBits() { var fmask = new FeatureMask(128); var masks = (UInt64[])ReflectionHelper.GetField(fmask, "m_masks"); fmask[15] = true; fmask[31] = true; fmask[47] = true; fmask[63] = true; Assert.AreEqual(0x8000800080008000, masks[0]); fmask[69] = true; fmask[85] = true; fmask[101] = true; fmask[117] = true; Assert.AreEqual(0x0020002000200020, masks[1]); }
public void Clear() { var fmask = new FeatureMask(256); Assert.IsFalse(fmask.IsAnyBitSet); fmask[60] = true; fmask[120] = true; fmask[200] = true; fmask[250] = true; Assert.IsTrue(fmask.IsAnyBitSet); Assert.IsFalse(fmask.IsEmpty); fmask.Clear(); Assert.IsFalse(fmask.IsAnyBitSet); Assert.IsFalse(fmask.IsEmpty); }
public void VerifyInternalMaskArraySize() { // Make the mask 64 bits long. var fmask = new FeatureMask(64); Assert.AreEqual(1, ReflectionHelper.GetField(fmask, "m_maskCount")); // Make the mask 65 bits long. fmask = new FeatureMask(65); Assert.AreEqual(2, ReflectionHelper.GetField(fmask, "m_maskCount")); // Make the mask 128 bits long. fmask = new FeatureMask(128); Assert.AreEqual(2, ReflectionHelper.GetField(fmask, "m_maskCount")); // Make the mask 129 bits long. fmask = new FeatureMask(129); Assert.AreEqual(3, ReflectionHelper.GetField(fmask, "m_maskCount")); }
/// ------------------------------------------------------------------------------------ public DefineFeatureClassDlgBase(ClassListViewItem classInfo, ClassesDlg classDlg, FeatureListViewBase lvFeatures, FeatureMask emptyMask) : base(classInfo ?? new ClassListViewItem { ClassType = SearchClassType.Articulatory }, classDlg) { _lvFeatures = lvFeatures; _lvFeatures.Load(); _lvFeatures.Dock = DockStyle.Fill; _lvFeatures.Visible = true; _lvFeatures.LabelEdit = false; _lvFeatures.FeatureChanged += HandleFeatureChanged; _lvFeatures.TabIndex = _textBoxClassName.TabIndex + 1; _lvFeatures.CurrentMask = (m_classInfo.Mask ?? emptyMask); SetupPhoneViewers(); SetupSplitters(); SetupRadioButtons(); UpdateCharacterViewers(); }
/// --------------------------------------------------------------------------------- private void GetFeatureMasksFromItems(List <string> items) { var distinctiveFeatureNames = (from fname in items.Where(i => i.StartsWith("F:")) where fname.StartsWith("+") || fname.StartsWith("-") select fname).ToList(); if (distinctiveFeatureNames.Count > 0) { _distinctiveFeatureMask = App.BFeatureCache.GetMask(distinctiveFeatureNames); } var descriptiveFeatureNames = (from fname in items.Where(i => i.StartsWith("F:")) where !fname.StartsWith("+") && !fname.StartsWith("-") select fname).ToList(); if (descriptiveFeatureNames.Count > 0) { _descriptiveFeatureMask = App.BFeatureCache.GetMask(descriptiveFeatureNames); } items = items.Where(i => !i.StartsWith("F:")).ToList(); }
public void ContainsAll() { var fmask1 = new FeatureMask(100); var fmask2 = new FeatureMask(100); fmask1[45] = true; fmask1[50] = true; fmask1[75] = true; Assert.IsFalse(fmask1.ContainsAll(fmask2)); fmask2[45] = true; Assert.IsTrue(fmask1.ContainsAll(fmask2)); fmask2[50] = true; Assert.IsTrue(fmask1.ContainsAll(fmask2)); fmask2[75] = true; Assert.IsTrue(fmask1.ContainsAll(fmask2)); fmask2[90] = true; Assert.IsFalse(fmask1.ContainsAll(fmask2)); }
/// ------------------------------------------------------------------------------------ private static void VerifyGroup_1(PatternGroup group, bool andMembers) { Assert.IsNotNull(group); Assert.AreEqual((andMembers ? GroupType.And : GroupType.Or), group.GroupType); Assert.AreEqual(2, group.Members.Count); var groupMember = group.Members[0] as PatternGroupMember; Assert.IsNotNull(groupMember); Assert.AreEqual(MemberType.Binary, groupMember.MemberType); Assert.AreEqual("+high", groupMember.Member); FeatureMask mask = App.BFeatureCache.GetMask("+high"); Assert.IsTrue(groupMember.BMask.ContainsOneOrMore(mask)); groupMember = group.Members[1] as PatternGroupMember; Assert.IsNotNull(groupMember); Assert.AreEqual(MemberType.Articulatory, groupMember.MemberType); Assert.AreEqual("dental", groupMember.Member); // Check the ToString just for kicks. Assert.AreEqual((andMembers ? "[[+high][dental]]" : "{[+high],[dental]}"), group.ToString()); }
/// ------------------------------------------------------------------------------------ protected override void CycleFeatureStateValue(FeatureItemInfo itemInfo, FeatureMask mask) { switch (itemInfo.TriStateValue) { case BinaryFeatureValue.None: itemInfo.TriStateValue = BinaryFeatureValue.Plus; mask[itemInfo.MinusBit] = false; mask[itemInfo.PlusBit] = true; break; case BinaryFeatureValue.Plus: itemInfo.TriStateValue = BinaryFeatureValue.Minus; mask[itemInfo.MinusBit] = true; mask[itemInfo.PlusBit] = false; break; default: itemInfo.TriStateValue = BinaryFeatureValue.None; mask[itemInfo.MinusBit] = false; mask[itemInfo.PlusBit] = false; break; } }
public void NotEqual() { var fmask1 = new FeatureMask(100); var fmask2 = new FeatureMask(100); fmask1[10] = true; fmask1[20] = true; fmask1[70] = true; fmask1[90] = true; var masks = (UInt64[])ReflectionHelper.GetField(fmask1, "m_masks"); Assert.IsTrue(masks[0] > 0); Assert.IsTrue(masks[1] > 0); fmask2[11] = true; fmask2[21] = true; fmask2[70] = true; fmask2[90] = true; masks = (UInt64[])ReflectionHelper.GetField(fmask2, "m_masks"); Assert.IsTrue(masks[0] > 0); Assert.IsTrue(masks[1] > 0); Assert.IsTrue(fmask1 != fmask2); }
public void BitGetting() { var fmask = new FeatureMask(100); fmask[45] = true; Assert.IsTrue(fmask[45]); fmask[45] = false; Assert.IsFalse(fmask[45]); fmask[60] = true; Assert.IsTrue(fmask[60]); fmask[60] = false; Assert.IsFalse(fmask[60]); fmask[80] = true; Assert.IsTrue(fmask[80]); fmask[80] = false; Assert.IsFalse(fmask[80]); fmask[75] = true; Assert.IsTrue(fmask[75]); fmask[75] = false; Assert.IsFalse(fmask[75]); }
/// ------------------------------------------------------------------------------------ private void HandleArticulatoryFeatureCheckChanged(object sender, FeatureMask newMask) { lblAFeatures.Text = m_lvAFeatures.FormattedFeaturesString; }
public void PatternGroupTest_Complex() { var group = _parser.Parse("[[{a,e}{[+high],[dental]}][-dorsal]]", EnvironmentType.After); Assert.IsNotNull(group); Assert.AreEqual(group.GroupType, GroupType.And); Assert.AreEqual(2, group.Members.Count); // Verify the second member of the group. var groupMember = group.Members[1] as PatternGroupMember; Assert.IsNotNull(groupMember); Assert.AreEqual(MemberType.Binary, groupMember.MemberType); Assert.AreEqual("-dorsal", groupMember.Member); FeatureMask mask = App.BFeatureCache.GetMask("-dorsal"); Assert.IsTrue(groupMember.BMask.ContainsOneOrMore(mask)); // Nested within the first group should be 2 other groups. PatternGroup nestedGroup = group.Members[0] as PatternGroup; Assert.IsNotNull(nestedGroup); Assert.AreEqual(2, nestedGroup.Members.Count); Assert.AreEqual(GroupType.And, nestedGroup.GroupType); // Verify the first group nested in the nested group. var nestedGroup1 = nestedGroup.Members[0] as PatternGroup; Assert.IsNotNull(nestedGroup1); Assert.AreEqual(2, nestedGroup1.Members.Count); Assert.AreEqual(GroupType.Or, nestedGroup1.GroupType); // Verify the first member of the nested, nested group. groupMember = nestedGroup1.Members[0] as PatternGroupMember; Assert.IsNotNull(groupMember); Assert.AreEqual(MemberType.SinglePhone, groupMember.MemberType); Assert.AreEqual("a", groupMember.Member); // Verify the second member of the nested, nested group. groupMember = nestedGroup1.Members[1] as PatternGroupMember; Assert.IsNotNull(groupMember); Assert.AreEqual(MemberType.SinglePhone, groupMember.MemberType); Assert.AreEqual("e", groupMember.Member); // Verify the second group nested in the nested group. var nestedGroup2 = nestedGroup.Members[1] as PatternGroup; Assert.IsNotNull(nestedGroup2); Assert.AreEqual(2, nestedGroup2.Members.Count); Assert.AreEqual(GroupType.Or, nestedGroup2.GroupType); // Verify the first member of the nested, nested group. groupMember = nestedGroup2.Members[0] as PatternGroupMember; Assert.IsNotNull(groupMember); Assert.AreEqual(MemberType.Binary, groupMember.MemberType); Assert.AreEqual("+high", groupMember.Member); mask = App.BFeatureCache.GetMask("+high"); Assert.IsTrue(groupMember.BMask.ContainsOneOrMore(mask)); // Verify the second member of the nested, nested group. groupMember = nestedGroup2.Members[1] as PatternGroupMember; Assert.IsNotNull(groupMember); Assert.AreEqual(MemberType.Articulatory, groupMember.MemberType); Assert.AreEqual("dental", groupMember.Member); mask = App.AFeatureCache.GetMask("dental"); Assert.IsTrue(groupMember.AMask.ContainsOneOrMore(mask)); }
/// ------------------------------------------------------------------------------------ protected override void SetFeatureInfoStateFromMask(FeatureItemInfo itemInfo, FeatureMask mask) { if (mask[itemInfo.PlusBit]) { itemInfo.TriStateValue = BinaryFeatureValue.Plus; } else if (mask[itemInfo.MinusBit]) { itemInfo.TriStateValue = BinaryFeatureValue.Minus; } else { itemInfo.TriStateValue = BinaryFeatureValue.None; } }