public IEnumerable<CollectedItem> CreateCollectedItemsWithOneErrorItem( ItemType itemType, IEnumerable<ProbeLogItem> logItems, string errorMessage) { itemType.message = MessageType.FromErrorString(errorMessage); itemType.status = StatusEnumeration.error; return CreateCollectedItems(itemType, logItems); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { if (systemItem.status.Equals(StatusEnumeration.notcollected)) { var userToBeCollected = ((user_item)systemItem).user.Value; try { var collectedUser = this.WindowsAccountProvider.GetUserByName(userToBeCollected); systemItem = new user_item() { status = StatusEnumeration.exists, user = OvalHelper.CreateItemEntityWithStringValue(collectedUser.Name), enabled = OvalHelper.CreateBooleanEntityItemFromBoolValue((bool)collectedUser.Enabled), }; var userGroups = this.WindowsAccountProvider.GetUserGroups(userToBeCollected, AccountSearchReturnType.Name); if (userGroups.Count() > 0) ((user_item)systemItem).group = userGroups.Select(grp => new EntityItemStringType() { Value = grp }).ToArray(); else ((user_item)systemItem).group = new EntityItemStringType[] { new EntityItemStringType() { status = StatusEnumeration.doesnotexist } }; } catch (WindowsUserNotFound) { systemItem.status = StatusEnumeration.doesnotexist; ((user_item)systemItem).user.status = systemItem.status; } } return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { this.CreateSMFCollectorInstance(); var smfItem = (smf_item)systemItem; try { var collectedSmf = this.TryToCollectSMF(smfItem.fmri.Value); smfItem.service_name = OvalHelper.CreateItemEntityWithStringValue(collectedSmf.ServiceName); smfItem.service_state = new EntityItemSmfServiceStateType() { Value = collectedSmf.ServiceState }; smfItem.protocol = new EntityItemSmfProtocolType() { Value = collectedSmf.Protocol }; smfItem.server_executable = OvalHelper.CreateItemEntityWithStringValue(collectedSmf.ServerExecutable); smfItem.server_arguements = OvalHelper.CreateItemEntityWithStringValue(collectedSmf.ServerArgs); smfItem.exec_as_user = OvalHelper.CreateItemEntityWithStringValue(collectedSmf.ExecAsUser); } catch (NoSMFDataException) { ExecutionLogBuilder.AddInfo("An error occurred while trying to collect smf_object"); smfItem.status = StatusEnumeration.error; smfItem.message = MessageType.FromErrorString("The fmri format is invalid."); smfItem.fmri.status = StatusEnumeration.error; } return new ItemTypeHelper().CreateCollectedItemsWithOneItem(smfItem, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { var filePath = string.Empty; try { var fileContentItem = (textfilecontent_item)systemItem; filePath = Path.Combine(fileContentItem.path.Value, fileContentItem.filename.Value); var interimList = WinNetUtils.getWinTextFileContent(hostUNC, filePath, fileContentItem.line.Value); var collectedItems = new List<CollectedItem>(); foreach (FileContentItemSystemData srcItem in interimList) { var destItem = new textfilecontent_item(); this.BuilderFileContentItem(destItem, srcItem, fileContentItem); var newCollectedItem = new CollectedItem() { ItemType = destItem, ExecutionLog = BuildExecutionLog() }; collectedItems.Add(newCollectedItem); } return collectedItems; } catch (FileNotFoundException) { base.SetDoesNotExistStatusForItemType(systemItem, filePath); } return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { var registryItem = (registry_item)systemItem; var fullKeyPath = Path.Combine(registryItem.hive.Value, registryItem.key.Value, registryItem.name.Value); var itemBuilder = new RegistryItemTypeBuilder(registryItem); try { base.ExecutionLogBuilder.CollectingDataFrom(fullKeyPath); if (this.IsAllEntitiesIsSet(systemItem)) { var collectedSystemData = this.collectSystemDataForRegistryItem(registryItem); itemBuilder.FillItemTypeWithData(collectedSystemData); } } catch (RegistryKeyNotFoundException) { base.ExecutionLogBuilder.Warning(string.Format("The registry key {0} is not found ", registryItem.key.Value)); itemBuilder.SetRegistryKeyStatus(StatusEnumeration.doesnotexist); itemBuilder.SetItemTypeStatus(StatusEnumeration.doesnotexist, null); itemBuilder.ClearRegistryName(); } catch (RegistryNameNotFoundException) { base.ExecutionLogBuilder.Warning(string.Format("The registry name {0} is not found ", registryItem.name.Value)); itemBuilder.SetRegistryNameStatus(StatusEnumeration.doesnotexist); itemBuilder.SetItemTypeStatus(StatusEnumeration.doesnotexist, null); } itemBuilder.BuildItemType(); itemBuilder.ClearEntitiesWithEmptyValueIfStatusDoesNotExists(); return new ItemTypeHelper().CreateCollectedItemsWithOneItem(itemBuilder.BuiltItemType, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { if (systemItem.status.Equals(StatusEnumeration.notcollected)) { var userSIDItem = ((user_sid_item)systemItem); try { var allUsers = this.WindowsAccountProvider.GetAllGroupByUsers(); var userSidValue = userSIDItem.user_sid.Value; var collectedUserItem = allUsers.Where(user => user.AccountSID.Equals(userSidValue)).FirstOrDefault(); if (collectedUserItem == null) throw new UserSIDNotFoundException(userSidValue); systemItem.status = StatusEnumeration.exists; userSIDItem.enabled = OvalHelper.CreateBooleanEntityItemFromBoolValue((bool)collectedUserItem.Enabled); userSIDItem.group_sid = new EntityItemStringType[] { new EntityItemStringType() { status = StatusEnumeration.doesnotexist } }; if ((collectedUserItem.Members != null) && (collectedUserItem.Members.Count() > 0)) userSIDItem.group_sid = collectedUserItem.Members.Select(grp => OvalHelper.CreateItemEntityWithStringValue(grp.AccountSID)).ToArray(); } catch (UserSIDNotFoundException) { SetDoesNotExistStatusForItemType(systemItem, userSIDItem.user_sid.Value); ((user_sid_item)systemItem).user_sid.status = StatusEnumeration.doesnotexist; } } return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { var xmlFilepath = string.Empty; var xmlFileContentItem = (xmlfilecontent_item)systemItem; try { xmlFilepath = this.GetCompleteFilepath(xmlFileContentItem); if (string.IsNullOrWhiteSpace(xmlFilepath)) throw new XPathNoResultException(); var xPathResult = this.XPathOperator.Apply(xmlFilepath, xmlFileContentItem.xpath.Value); this.ConfigureXmlFileContentItem(xmlFileContentItem, xPathResult); } catch (FileNotFoundException) { var completeFilepath = this.GetCompleteFilepath((xmlfilecontent_item)xmlFileContentItem); base.SetDoesNotExistStatusForItemType(systemItem, completeFilepath); } catch (XPathNoResultException) { var xpath = string.Format("xpath: '{0}'", xmlFileContentItem.xpath.Value); base.SetDoesNotExistStatusForItemType(systemItem, xpath); } return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { var filepath = string.Empty; var trusteeSID = string.Empty; try { filepath = ((fileauditedpermissions_item)systemItem).filepath.Value; trusteeSID = ((fileauditedpermissions_item)systemItem).trustee_sid.Value; base.ExecutionLogBuilder.AddInfo(string.Format(TRYING_TO_COLLECT_AUDITED_PERMISSIONS_LOG, trusteeSID, filepath)); CreateFileAuditedPermissions53ItemType((fileauditedpermissions_item)systemItem, filepath, trusteeSID); var SACLs = this.CollectSecurityDescriptorForFileAndUser(filepath, trusteeSID); MapSACLsToFileAuditedPermissionsItem((fileauditedpermissions_item)systemItem, SACLs); } catch (InvalidInvokeMethodException) { base.SetDoesNotExistStatusForItemType(systemItem, filepath); this.SetAllAuditEntitiesItemToNULL((fileauditedpermissions_item)systemItem); } catch (ACLNotFoundException) { base.SetDoesNotExistStatusForItemType(systemItem, trusteeSID); } catch (Exception ex) { this.SetAllAuditEntitiesItemToEMPTY((fileauditedpermissions_item)systemItem); throw ex; } return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
public RunLevelProberTests() { FakeItemToCollect1 = CreateFakeRunlevelItem("ssh", "2", null, null); FakeItemToCollect2 = CreateFakeRunlevelItem("cups", "3", null, null); FakeCollectedItem1 = ProbeHelper.CreateFakeCollectedItem(CreateFakeRunlevelItem("ssh", "2", "0", "1")); FakeCollectedItem2 = ProbeHelper.CreateFakeCollectedItem(CreateFakeRunlevelItem("cups", "3", "1", "0")); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { var metabaseItem = (metabase_item)systemItem; try { if (string.IsNullOrWhiteSpace(MetabaseFileContent) || string.IsNullOrWhiteSpace(MetabaseSchemaContent)) throw new Exception(METABASE_CONTENT_NOT_FOUND_MSG); var metabaseSession = GetMetabaseProperty(metabaseItem.key.Value, metabaseItem.id1.Value); metabaseItem.data = CreateMetabaseEntityItemFromMetabaseDataProperty(metabaseSession.Value); if ((metabaseItem.data.Length == 1) && (metabaseItem.data[0].status == StatusEnumeration.doesnotexist)) { metabaseItem.status = StatusEnumeration.doesnotexist; metabaseItem.id1.status = StatusEnumeration.doesnotexist; metabaseItem.name = null; metabaseItem.data_type = null; metabaseItem.user_type = null; } else { metabaseItem.name = CreateMetabaseEntityFromMetabaseProperty(metabaseSession.Name); metabaseItem.data_type = CreateMetabaseEntityFromMetabaseProperty(metabaseSession.Type); metabaseItem.user_type = CreateMetabaseEntityFromMetabaseProperty(metabaseSession.UserType); } } catch (MetabaseItemNotFoundException) { metabaseItem.status = StatusEnumeration.doesnotexist; metabaseItem.key.status = metabaseItem.status; } return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { base.ExecutionLogBuilder.CollectingDataFrom(TargetHostName); var collectedPasswordPolicies = PasswordPolicyHelper.getUserModalsInfo0(TargetHostName); this.MapPasswrodPolicyToPasswordPolicyItemType((passwordpolicy_item)systemItem, collectedPasswordPolicies); return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, base.BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { this.CreateWmiDataProviderFromWmiItem((wmi_item)systemItem); var wmiResult = this.WmiDataProvider.ExecuteWQL(((wmi_item)systemItem).wql.Value); ((wmi_item)systemItem).result = this.ConvertWmiResultToEntityItemList(wmiResult); return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { base.ExecutionLogBuilder.CollectingDataFrom("Family Object"); var collectedFamily = this.FamilyCollector.GetOperatingSystemFamily(); ((family_item)systemItem).family = new EntityItemFamilyType() { Value = collectedFamily }; return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { var commandOutput = UnameCollector.RunUnameCommand(); UnixTerminalParser .MapUnameCommandOutputToUnameItem((uname_item)systemItem, commandOutput); return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
public static void AssertItemTypeWithErrorStatus(ItemType itemToAssert, string expectedChunkOfMessageTypeValue) { Assert.AreEqual(StatusEnumeration.error, itemToAssert.status, "Unexpected item status was found."); if (!string.IsNullOrEmpty(expectedChunkOfMessageTypeValue)) { Assert.IsNotNull(itemToAssert.message, "The message type was not created."); Assert.IsTrue(itemToAssert.message.First().Value.Contains(expectedChunkOfMessageTypeValue)); } }
public static void AssertItemsWithExistsStatus(ItemType[] itemsToAssert, int expectedItemCount, Type expectedTypeInstanceOfItems) { Assert.AreEqual(expectedItemCount, itemsToAssert.Count(), "Unexpected system data items count was found."); foreach (var itemType in itemsToAssert) { Assert.IsInstanceOfType(itemType, expectedTypeInstanceOfItems, "An item with unexpected instance type was found."); Assert.AreEqual(StatusEnumeration.exists, itemType.status, "An item with unexpected status was found."); } }
public RpmInfoProberTests() { FakeItemToCollect1 = CreateFakeRpmInfoItem("vbox", null, null, null, null, null); FakeItemToCollect2 = CreateFakeRpmInfoItem("firefox", null, null, null, null, null); var fakeCollectedItem1 = CreateFakeRpmInfoItem("vbox", "x86", "2010", "1020", "12345678", "1"); FakeCollectedItem1 = ProbeHelper.CreateFakeCollectedItem(fakeCollectedItem1); var fakeCollectedItem2 = CreateFakeRpmInfoItem("firefox", "x86", "2010", "1020", "12345678", "1"); FakeCollectedItem2 = ProbeHelper.CreateFakeCollectedItem(fakeCollectedItem2); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { base.ExecutionLogBuilder.CollectingDataFrom(TargetHostName); var securityPrincipleEntity = ((accesstoken_item)systemItem).security_principle; var collectedAccessToken = this.AccessTokenProvider.GetAccessTokens(this.TargetHostName, securityPrincipleEntity.Value); new AccessTokenItemTypeBuilder().FillItemTypeWithData((accesstoken_item)systemItem, collectedAccessToken); return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
protected void SetDoesNotExistStatusForItemType(ItemType systemItem, string itemIdentifier) { systemItem.status = StatusEnumeration.doesnotexist; if (!string.IsNullOrEmpty(itemIdentifier)) { var messageToLog = string.Format(ITEM_NOT_FOUND_LOG_MESSAGE, ObjectCollectorName, itemIdentifier); this.ExecutionLogBuilder.AddInfo(messageToLog); } }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { CreateAuditEventPolicyHelper(); var itemTypeBuilder = new AuditEventPolicyItemTypeBuilder(systemItem); var auditEventPolicies = this.AuditEventPolicyHelper.GetAuditEventPolicies(this.TargetInfo); itemTypeBuilder.FillItemTypeWithData(auditEventPolicies); itemTypeBuilder.SetItemTypeStatus(StatusEnumeration.exists, null); return new ItemTypeHelper().CreateCollectedItemsWithOneItem(itemTypeBuilder.BuiltItemType, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { if (this.AuditEventPolicyHelper == null) this.AuditEventPolicyHelper = new AuditEventPolicyHelper(this.TargetInfo); var auditEventPolicySubcategories = this.AuditEventPolicyHelper.GetAuditEventSubcategoriesPolicy(this.TargetInfo); this.MapAuditEventSubcategoriesDictionaryToItemType(auditEventPolicySubcategories, (auditeventpolicysubcategories_item)systemItem); return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { try { string trusteeSID = ((sid_sid_item)systemItem).trustee_sid.Value; base.ExecutionLogBuilder.CollectingDataFrom(trusteeSID); this.collectSidItemSystemData((sid_sid_item)systemItem); } catch (KeyNotFoundException) { SetTrusteeSIDEntityStatus((sid_sid_item)systemItem, StatusEnumeration.doesnotexist); } return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
public void Should_be_possible_to_collect_file_object_for_unix_systems() { var fakeFileItemsToReturn = new ItemType[] { new unix.file_item() { filepath = OvalHelper.CreateItemEntityWithStringValue("/home/usr/readme") } }; var fakeCollectedItemsToReturn = new CollectedItem[] { ProbeHelper.CreateFakeCollectedItem(CreateFileItem()) }; var unixFileProber = new FileProber(); ProberBehaviorCreator .CreateBehaviorForNormalFlowExecution( unixFileProber, fakeFileItemsToReturn, fakeCollectedItemsToReturn); var result = unixFileProber.Execute(FakeContext, FakeTargetInfo, GetFakeCollectInfo("oval:modulo:obj:2", "definitions_all_unix")); DoAssertForSingleCollectedObject(result, typeof(unix.file_item)); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { var lineSubCommand = ((line_item)systemItem).show_subcommand.Value; try { var commandOutput = TelnetConnection.CiscoCommand(lineSubCommand); ((line_item)systemItem).config_line = OvalHelper.CreateItemEntityWithStringValue(commandOutput); } catch (NoCommandOutputException) { systemItem.status = StatusEnumeration.doesnotexist; } return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { var wmiItemType = ((wmi57_item)systemItem); var wmiDataProvider = this.GetWmiDataProvider([email protected]); var wmiResult = wmiDataProvider.ExecuteWQL(wmiItemType.wql.Value); if (wmiResult.Count() == 0) { wmiItemType.status = StatusEnumeration.doesnotexist; wmiItemType.result = new[] { new EntityItemRecordType() { status = StatusEnumeration.doesnotexist } }; } else this.ConfigureWmiItemResult(wmiItemType, wmiResult); return new ItemTypeHelper().CreateCollectedItemsWithOneItem(wmiItemType, BuildExecutionLog()); }
public virtual IEnumerable<CollectedItem> CollectDataForSystemItem(ItemType systemItem) { try { if (systemItem.status.Equals(StatusEnumeration.exists) || systemItem.status.Equals(StatusEnumeration.notcollected)) return this.collectDataForSystemItem(systemItem); else return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); } catch (Exception ex) { AddAWarningMessageInExecutionLog(ex.Message); ConfigureItemTypeAsErrorItem(systemItem, ex.Message); return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); } }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { string trusteeName = string.Empty; try { trusteeName = ((sid_item)systemItem).trustee_name.Value; base.ExecutionLogBuilder.CollectingDataFrom(trusteeName); this.CollectSidItemSystemData((sid_item)systemItem); } catch (KeyNotFoundException) { base.SetDoesNotExistStatusForItemType(systemItem, trusteeName); this.SetTrusteeNameEntityStatus((sid_item)systemItem, StatusEnumeration.doesnotexist); } return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { this.CreateEnvironmentVariablesCollectorInstance(); var environmentVariableItem = (environmentvariable_item)systemItem; try { var collectedVariableValue = this.TryToCollectEnvironmentVariable(environmentVariableItem.name.Value); environmentVariableItem.value = OvalHelper.CreateEntityItemAnyTypeWithValue(collectedVariableValue); } catch (EnvironmentVariableNotExistsException) { base.SetDoesNotExistStatusForItemType(systemItem, environmentVariableItem.name.Value); } return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { var groupItem = (group_item)systemItem; var groupName = groupItem.group.Value; try { base.ExecutionLogBuilder.CollectingDataFrom(groupName); this.CollectGroupItemSystemData(groupItem); } catch (KeyNotFoundException) { base.SetDoesNotExistStatusForItemType(groupItem, groupName); this.SetGroupEntityStatus(groupItem.group, StatusEnumeration.doesnotexist); } return new ItemTypeHelper().CreateCollectedItemsWithOneItem(groupItem, BuildExecutionLog()); }
protected override IEnumerable<CollectedItem> collectDataForSystemItem(ItemType systemItem) { this.CheckGroupProviderInstance(); var groupSIDToCollect = string.Empty; try { groupSIDToCollect = ((group_sid_item)systemItem).group_sid.Value; var windowsGroupAccount = this.WindowsGroupProvider.CollectWindowsGroupAccountInfoBySID(groupSIDToCollect); this.FillItemTypeWithData((group_sid_item)systemItem, windowsGroupAccount); } catch (GroupSIDNotFoundException) { SetDoesNotExistStatusForItemType(systemItem, groupSIDToCollect); } return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog()); }
private void assertCollectedItemStatus(SystemCharacteristics.ReferenceType objectReference, SystemCharacteristics.ItemType collectedItem) { Assert.IsInstanceOfType(collectedItem, typeof(fileeffectiverights_item), "The generated ItemType must be a instance of fileeffectiverights_item class."); Assert.AreEqual(objectReference.item_ref, collectedItem.id, "The generated ItemType ID must be equal to collected object ID."); Assert.AreEqual(StatusEnumeration.exists, collectedItem.status, "A generated ItemType with unexpected OVAL Status was found."); }
private void assertFileEffectiveRightsInitialEntities(Definitions.ObjectType sourceObject, SystemCharacteristics.ItemType collectedItem) { fileeffectiverights_item collectedFileEffectiveRightsItem = (fileeffectiverights_item)collectedItem; var allExpectedEntities = OvalHelper.GetFileEffectiveRightsFromObjectType((fileeffectiverights_object)sourceObject); string expectedPath = allExpectedEntities[fileeffectiverights_object_ItemsChoices.path.ToString()].Value; string expectedFileName = allExpectedEntities[fileeffectiverights_object_ItemsChoices.filename.ToString()].Value; string expectedTrusteeName = allExpectedEntities[fileeffectiverights_object_ItemsChoices.trustee_name.ToString()].Value; Assert.AreEqual(expectedPath, collectedFileEffectiveRightsItem.path.Value, string.Format(MSG_UNEXPECTED_COLLECTED_ITEM_VALUE, "path")); Assert.AreEqual(expectedFileName, collectedFileEffectiveRightsItem.filename.Value, string.Format(MSG_UNEXPECTED_COLLECTED_ITEM_VALUE, "filename")); Assert.AreEqual(expectedTrusteeName, collectedFileEffectiveRightsItem.trustee_name.Value, string.Format(MSG_UNEXPECTED_COLLECTED_ITEM_VALUE, "trustee_name")); }