private UInt32Value GetSegmentMatchColor(ITranslationOrigin origin)
{
UInt32Value result = NoMatch;
if (origin == null)
{
return(NoMatch);
}
if (origin.IsStructureContextMatch || origin.TextContextMatchLevel == TextContextMatchLevel.SourceAndTarget)
{
result = ContextMatch;
}
else
{
if (origin.MatchPercent == 100)
{
result = ExactMatch;
}
if (origin.MatchPercent > 0 && origin.MatchPercent < 100)
{
result = FuzzyMatch;
}
if (origin.MatchPercent == 0)
{
result = NoMatch;
}
}
return(result);
}
private bool IsImprovementToTpTranslation(ITranslationOrigin translationOrigin, SegmentId segmentId, ISegment segment)
{
return(translationOrigin?.OriginBeforeAdaptation?.OriginSystem == PluginResources.SDLMTCloudName &&
ActiveDocumentImprovements.ContainsKey(segmentId) &&
ActiveDocumentImprovements[segmentId].OriginalMtCloudTranslation != segment.ToString() &&
segment.Properties?.ConfirmationLevel == ConfirmationLevel.Translated);
}
public SegmentCountInfo(ITranslationOrigin translationOrigin, CountData countData, bool isLocked, int spaceCount)
{
TranslationOrigin = translationOrigin;
CountData = countData;
IsLocked = isLocked;
SpaceCount = spaceCount;
}
private bool SkipSegment(ISegmentPair segmentPair)
{
ITranslationOrigin origin = segmentPair.Properties.TranslationOrigin;
ConfirmationLevel confLevel = segmentPair.Properties.ConfirmationLevel;
if (_convertSettings.ExcludeExportType == GeneratorSettings.ExclusionType.Locked &&
segmentPair.Properties.IsLocked)
{
return(true);
}
else
{
if (_convertSettings.ExcludeExportType == GeneratorSettings.ExclusionType.Status)
{
if (_convertSettings.ExcludedStatuses.Contains(confLevel))
{
return(true);
}
}
else
{
if (origin == null)
{
if (_convertSettings.DontExportNoMatch)
{
return(true);
}
else
{
return(false);
}
}
if ((origin.TextContextMatchLevel == TextContextMatchLevel.SourceAndTarget) &&
_convertSettings.DontExportContext)
{
return(true);
}
else
{
if (origin.MatchPercent == 100 && _convertSettings.DontExportExact)
{
return(true);
}
if ((origin.MatchPercent > 0 && origin.MatchPercent < 100) && _convertSettings.DontExportFuzzy)
{
return(true);
}
if (origin.MatchPercent == 0 && _convertSettings.DontExportNoMatch)
{
return(true);
}
}
}
}
return(false);
}
public static string GetTranslationStatus(ITranslationOrigin translationOrigin)
{
var match = string.Empty;
if (translationOrigin == null)
{
return(match);
}
if (string.Compare(translationOrigin.OriginType, "interactive", StringComparison.OrdinalIgnoreCase) == 0)
{
// nothing to do here
}
else if (string.Compare(translationOrigin.OriginType, "auto-propagated", StringComparison.OrdinalIgnoreCase) == 0)
{
match = "REPS";
}
else
{
if (translationOrigin.MatchPercent >= 100)
{
if (
string.Compare(translationOrigin.OriginType, "document-match",
StringComparison.OrdinalIgnoreCase) == 0)
{
match = "PM";
}
else if (translationOrigin.TextContextMatchLevel == TextContextMatchLevel.SourceAndTarget)
{
match = "CM";
}
else if (string.Compare(translationOrigin.OriginType, "mt", StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(translationOrigin.OriginType, "nmt", StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(translationOrigin.OriginType, "amt", StringComparison.OrdinalIgnoreCase) == 0)
{
match = "AT";
}
else
{
match = translationOrigin.MatchPercent + "%";
}
}
else if (string.Compare(translationOrigin.OriginType, "mt", StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(translationOrigin.OriginType, "nmt", StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(translationOrigin.OriginType, "amt", StringComparison.OrdinalIgnoreCase) == 0)
{
match = "AT";
}
else if (translationOrigin.MatchPercent > 0)
{
match = translationOrigin.MatchPercent + "%";
}
else
{
match = string.Empty;
}
}
return(match);
}
private bool IsAutomatedTranslated(ITranslationOrigin translationOrigin)
{
var originType = translationOrigin?.OriginType;
return(!string.IsNullOrEmpty(originType) &&
(originType.Equals(DefaultTranslationOrigin.MachineTranslation) ||
originType.Equals(DefaultTranslationOrigin.NeuralMachineTranslation) ||
originType.Equals(DefaultTranslationOrigin.AdaptiveMachineTranslation)));
}
private void AnonymizeToDefaultValues(ITranslationOrigin translationOrigin, bool isTmAnonymization)
{
translationOrigin.OriginType = DefaultTranslationOrigin.Interactive;
translationOrigin.OriginSystem = string.Empty;
if (!isTmAnonymization)
{
translationOrigin.MatchPercent = byte.Parse("0");
}
}
private void ReplaceTranslationOrigin(ITranslationOrigin translationOrigin, string newOrigin)
{
if (!string.IsNullOrEmpty(translationOrigin?.OriginType))
{
if (translationOrigin.OriginType.Equals("nmt") || translationOrigin.OriginType.Equals("mt"))
{
translationOrigin.OriginType = newOrigin;
}
}
}
public string GetTranslationOriginType(ITranslationOrigin translationOrigin)
{
if (translationOrigin != null)
{
if (translationOrigin.OriginType == DefaultTranslationOrigin.AutoPropagated)
{
return(MatchType.Repetition.ToString());
}
if (translationOrigin.OriginType == DefaultTranslationOrigin.MachineTranslation)
{
return(MatchType.MT.ToString());
}
if (translationOrigin.OriginType == DefaultTranslationOrigin.AdaptiveMachineTranslation)
{
return(MatchType.AMT.ToString());
}
if (translationOrigin.OriginType == DefaultTranslationOrigin.NeuralMachineTranslation)
{
return(MatchType.NMT.ToString());
}
if (translationOrigin.MatchPercent >= 100)
{
if (translationOrigin.OriginType == DefaultTranslationOrigin.DocumentMatch)
{
return(MatchType.PM.ToString());
}
if (translationOrigin.TextContextMatchLevel == TextContextMatchLevel.SourceAndTarget)
{
return(MatchType.CM.ToString());
}
return(MatchType.Exact.ToString());
}
if (translationOrigin.MatchPercent > 0)
{
foreach (var analysisBand in _analysisBands)
{
if (translationOrigin.MatchPercent >= analysisBand.MinimumMatchValue &&
translationOrigin.MatchPercent <= analysisBand.MaximumMatchValue)
{
return(string.Format("{0} {1} - {2}", MatchType.Fuzzy.ToString(),
analysisBand.MinimumMatchValue + "%", analysisBand.MaximumMatchValue + "%"));
}
}
}
}
return(MatchType.New.ToString());
}
private void EditUserMetadata(ITranslationOrigin translationOrigin, string metadataKey, string metadataValue)
{
var containsKey = translationOrigin.MetaDataContainsKey(metadataKey);
if (!containsKey)
{
return;
}
translationOrigin.RemoveMetaData(metadataKey);
translationOrigin.SetMetaData(metadataKey, metadataValue);
}
private void AnonymizeTmMatch(ITranslationOrigin translationOrigin)
{
translationOrigin.OriginType = DefaultTranslationOrigin.TranslationMemory;
if (!string.IsNullOrEmpty(_settings.TmName))
{
translationOrigin.OriginSystem = Path.GetFileNameWithoutExtension(_settings.TmName);
}
var fuzzy = _settings.FuzzyScore.ToString(CultureInfo.InvariantCulture);
translationOrigin.MatchPercent = byte.Parse(fuzzy);
}
private static bool IsFuzzyMatch(ITranslationOrigin translationOrigin)
{
var originType = translationOrigin?.OriginType;
if (string.Compare(originType, "mt", StringComparison.InvariantCultureIgnoreCase) == 0
|| string.Compare(originType, "nmt", StringComparison.InvariantCultureIgnoreCase) == 0)
{
return false;
}
var match = translationOrigin?.MatchPercent ?? 0;
return match != 0 && match < 100;
}
public static OriginType GetOriginType(this ITranslationOrigin translationOrigin)
{
if (translationOrigin == null)
{
return(OriginType.None);
}
if (string.Compare(translationOrigin.OriginType, "auto-propagated", StringComparison.OrdinalIgnoreCase) == 0)
{
return(OriginType.AutoPropagated);
}
else if (string.Compare(translationOrigin.OriginType, "interactive", StringComparison.OrdinalIgnoreCase) == 0)
{
return(OriginType.Interactive);
}
else
{
if (translationOrigin.MatchPercent >= 100)
{
if (string.Compare(translationOrigin.OriginType, "document-match", StringComparison.OrdinalIgnoreCase) == 0)
{
return(OriginType.PM);
}
else if (translationOrigin.TextContextMatchLevel == TextContextMatchLevel.SourceAndTarget)
{
return(OriginType.CM);
}
else if (string.Compare(translationOrigin.OriginType, "mt", StringComparison.OrdinalIgnoreCase) == 0)
{
return(OriginType.AT);
}
else
{
return(OriginType.Exact);
}
}
else if (string.Compare(translationOrigin.OriginType, "mt", StringComparison.OrdinalIgnoreCase) == 0)
{
return(OriginType.AT);
}
else if (translationOrigin.MatchPercent > 0)
{
return(OriginType.Fuzzy);
}
else if (string.Compare(translationOrigin.OriginType, "source", StringComparison.OrdinalIgnoreCase) == 0)
{
return(OriginType.Source);
}
}
return(OriginType.None);
}
public static bool IsEditedFuzzyMatch(ITranslationOrigin translationOrigin)
{
if (translationOrigin?.OriginBeforeAdaptation != null)
{
var originType = translationOrigin.OriginType;
if (string.Compare(originType, "interactive", StringComparison.InvariantCultureIgnoreCase) == 0 &&
IsFuzzyMatch(translationOrigin.OriginBeforeAdaptation))
{
return(true);
}
}
return(false);
}
// helper function for creating paragraph units
private IParagraphUnit CreateParagraphUnit(XmlNode xmlUnit)
{
// create paragraph unit object
IParagraphUnit paragraphUnit = ItemFactory.CreateParagraphUnit(LockTypeFlags.Unlocked);
// create paragraph unit context
string id = xmlUnit.SelectSingleNode("./@SegID").InnerText;
paragraphUnit.Properties.Contexts = CreateContext("Paragraph", id);
foreach (XmlNode item in xmlUnit.SelectNodes("."))
{
// create segment pair object
ISegmentPairProperties segmentPairProperties = ItemFactory.CreateSegmentPairProperties();
ITranslationOrigin tuOrg = ItemFactory.CreateTranslationOrigin();
// assign the appropriate confirmation level to the segment pair
segmentPairProperties.ConfirmationLevel = CreateConfirmationLevel(item);
tuOrg.MatchPercent = CreateMatchValue(item);
// add source segment to paragraph unit
ISegment srcSegment = CreateSegment(_srcDocument.SelectSingleNode("//Seg[@SegID='" + id + "']"), segmentPairProperties, true);
paragraphUnit.Source.Add(srcSegment);
// add target segment to paragraph unit if available
if (item.SelectSingleNode(".") != null)
{
ISegment trgSegment = CreateSegment(item.SelectSingleNode("."), segmentPairProperties, false);
paragraphUnit.Target.Add(trgSegment);
}
else
{
item.SelectSingleNode(".").InnerText = "";
ISegment trgSegment = CreateSegment(item.SelectSingleNode("."), segmentPairProperties, false);
paragraphUnit.Target.Add(trgSegment);
}
if (tuOrg.MatchPercent > 0)
{
tuOrg.OriginType = DefaultTranslationOrigin.TranslationMemory;
}
segmentPairProperties.TranslationOrigin = tuOrg;
}
return(paragraphUnit);
}
private static void WriteTranslationOrigin(XmlWriter writer, ITranslationOrigin translationOrigin)
{
var originType = translationOrigin != null ? translationOrigin.OriginType : string.Empty;
var originSystem = translationOrigin != null ? translationOrigin.OriginSystem : string.Empty;
var matchPercentage = translationOrigin?.MatchPercent.ToString() ?? "0";
var structMatch = translationOrigin?.IsStructureContextMatch.ToString() ?? string.Empty;
var textMatch = translationOrigin?.TextContextMatchLevel != null
? translationOrigin.TextContextMatchLevel.ToString()
: string.Empty;
if (!string.IsNullOrEmpty(originType))
{
writer.WriteAttributeString("origin", originType);
}
if (!string.IsNullOrEmpty(originSystem))
{
writer.WriteAttributeString("origin-system", originSystem);
}
if (!string.IsNullOrEmpty(matchPercentage) && matchPercentage != "0")
{
writer.WriteAttributeString("percent", matchPercentage);
}
if (!string.IsNullOrEmpty(structMatch) && structMatch != "False")
{
writer.WriteAttributeString("struct-match", structMatch);
}
if (!string.IsNullOrEmpty(textMatch) && textMatch != "None")
{
writer.WriteAttributeString("text-match", textMatch);
}
//if (translationOrigin?.MetaData != null)
//{
// foreach (var keyValuePair in translationOrigin.MetaData)
// {
// writer.WriteStartElement(nsPrefix, "value", null);
// writer.WriteAttributeString("key", keyValuePair.Key);
// writer.WriteString(keyValuePair.Value);
// writer.WriteEndElement(); //sdl:value
// }
//}
}
private void AnonymizeMtTranslationOrigin(ISegmentPair segmentPair, IBatchAnonymizerSettings anonymizerSettings,
ITranslationOrigin translationOrigin)
{
var anonymizeCustomResources = ShouldAnonymizeAtWithCustomResources(anonymizerSettings);
AnonymizeToDefaultValues(translationOrigin); // we need to set the origin to be interactive in order to have edied fuzzy
if (anonymizeCustomResources)
{
if (segmentPair.Properties?.TranslationOrigin.OriginBeforeAdaptation == null)
{
var originClone = (ITranslationOrigin)translationOrigin.Clone();
originClone.OriginBeforeAdaptation = null;
segmentPair.Properties.TranslationOrigin.OriginBeforeAdaptation = originClone;
}
AnonymizeTmMatch(segmentPair.Properties.TranslationOrigin.OriginBeforeAdaptation, anonymizerSettings, false);
}
}
// helper function for creating paragraph units
private IParagraphUnit CreateParagraphUnit(XmlNode xmlUnit)
{
// create paragraph unit object
IParagraphUnit paragraphUnit = ItemFactory.CreateParagraphUnit(LockTypeFlags.Unlocked);
// create paragraph unit context
segId++;
string id = Convert.ToString(segId);
paragraphUnit.Properties.Contexts = CreateContext("Paragraph", id);
// create segment pair object
ISegmentPairProperties segmentPairProperties = ItemFactory.CreateSegmentPairProperties();
ITranslationOrigin tuOrg = ItemFactory.CreateTranslationOrigin();
// assign the appropriate confirmation level to the segment pair
segmentPairProperties.ConfirmationLevel = CreateConfirmationLevel(xmlUnit);
tuOrg.MatchPercent = this.CreateMatchValue();
// add source segment to paragraph unit
ISegment srcSegment = CreateSegment(xmlUnit.SelectSingleNode("tuv[1]/seg"), segmentPairProperties);
paragraphUnit.Source.Add(srcSegment);
// add target segment to paragraph unit
ISegment trgSegment = CreateSegment(xmlUnit.SelectSingleNode("tuv[2]/seg"), segmentPairProperties);
paragraphUnit.Target.Add(trgSegment);
if (tuOrg.MatchPercent > 0)
{
tuOrg.OriginType = DefaultTranslationOrigin.TranslationMemory;
}
segmentPairProperties.TranslationOrigin = tuOrg;
return(paragraphUnit);
}
// helper function for creating paragraph units
private IParagraphUnit CreateParagraphUnit(XmlNode xmlUnit)
{
// create paragraph unit object
IParagraphUnit paragraphUnit = ItemFactory.CreateParagraphUnit(LockTypeFlags.Unlocked);
// create paragraph unit context
var selectSingleNode = xmlUnit.SelectSingleNode("./@blockId");
if (selectSingleNode != null)
{
string id = selectSingleNode.InnerText;
paragraphUnit.Properties.Contexts = CreateContext(id);
}
var xmlNodeList = xmlUnit.SelectNodes("segment");
if (xmlNodeList != null)
{
foreach (XmlNode item in xmlNodeList)
{
// create segment pair object
ISegmentPairProperties segmentPairProperties = ItemFactory.CreateSegmentPairProperties();
ITranslationOrigin tuOrg = ItemFactory.CreateTranslationOrigin();
// assign the appropriate confirmation level to the segment pair
segmentPairProperties.ConfirmationLevel = CreateConfirmationLevel(item);
tuOrg.MatchPercent = CreateMatchValue(item);
// add source segment to paragraph unit
ISegment srcSegment = CreateSegment(item.SelectSingleNode("source"), segmentPairProperties, true);
paragraphUnit.Source.Add(srcSegment);
// add target segment to paragraph unit if available
if (item.SelectSingleNode("target") != null)
{
ISegment trgSegment = CreateSegment(item.SelectSingleNode("target"), segmentPairProperties, false);
paragraphUnit.Target.Add(trgSegment);
}
else
{
var singleNode = item.SelectSingleNode("source");
if (singleNode != null)
{
singleNode.InnerText = "";
}
ISegment trgSegment = CreateSegment(item.SelectSingleNode("source"), segmentPairProperties, false);
paragraphUnit.Target.Add(trgSegment);
}
if (tuOrg.MatchPercent > 0)
{
tuOrg.OriginType = DefaultTranslationOrigin.TranslationMemory;
}
segmentPairProperties.TranslationOrigin = tuOrg;
//Add comments
if (item.SelectSingleNode("comments") != null)
{
paragraphUnit.Properties.Comments = CreateComment(item.SelectSingleNode("comments"));
}
}
}
return(paragraphUnit);
}
private UInt32Value GetSegmentMatchColor(ITranslationOrigin origin)
{
UInt32Value result = NoMatch;
if (origin == null)
{
return NoMatch;
}
if (origin.IsStructureContextMatch || origin.TextContextMatchLevel == TextContextMatchLevel.SourceAndTarget)
{
result = ContextMatch;
}
else
{
if (origin.MatchPercent == 100)
{
result = ExactMatch;
}
if (origin.MatchPercent > 0 && origin.MatchPercent < 100)
{
result = FuzzyMatch;
}
if (origin.MatchPercent == 0)
{
result = NoMatch;
}
}
return result;
}
private void AnonymizeTmTransaltionOrigin(IBatchAnonymizerSettings anonymizerSettings, ITranslationOrigin translationOrigin)
{
var anonymizeWithCustomRes = ShouldAnonymizeTmWithCustomResources(anonymizerSettings);
if (!anonymizeWithCustomRes)
{
AnonymizeToDefaultValues(translationOrigin);
}
else
{
AnonymizeTmMatch(translationOrigin, anonymizerSettings, true);
}
}
private bool IsTmTransaltion(ITranslationOrigin translationOrigin)
{
var originType = translationOrigin?.OriginType;
return(!string.IsNullOrEmpty(originType) && originType.Equals(DefaultTranslationOrigin.TranslationMemory));
}
private List <IParagraphUnit> CreateParagraphUnit(XmlNode xmlUnit)
{
List <IParagraphUnit> units = new List <IParagraphUnit>();
var xmlNodes = xmlUnit.SelectNodes("x:trans-unit", nsmgr);
foreach (XmlNode xmlNode in xmlNodes)
{
// Create paragraph unit object
IParagraphUnit paragraphUnit = ItemFactory.CreateParagraphUnit(LockTypeFlags.Unlocked);
if (xmlNode != null)
{
var id = xmlNode.Attributes["id"];
var paraId = xmlNode.Attributes["m:para-id"];
if (id != null && paraId != null)
{
paragraphUnit.Properties.Contexts = CreateContext(id.Value, paraId.Value);
}
// Create segment pair object
ISegmentPairProperties segmentPairProperties = ItemFactory.CreateSegmentPairProperties();
ITranslationOrigin tuOrg = ItemFactory.CreateTranslationOrigin();
// Assign the appropriate confirmation level to the segment pair
segmentPairProperties.ConfirmationLevel = CreateConfirmationLevel(xmlNode);
tuOrg.MatchPercent = CreateMatchValue(xmlNode);
// Add source segment to paragraph unit
ISegment srcSegment = CreateSegment(xmlNode.SelectSingleNode("x:source", nsmgr), segmentPairProperties, true);
paragraphUnit.Source.Add(srcSegment);
// Add target segment to paragraph unit if available
if (xmlNode.SelectSingleNode("x:target", nsmgr) != null)
{
ISegment trgSegment = CreateSegment(xmlNode.SelectSingleNode("x:target", nsmgr), segmentPairProperties, false);
// Check if locked
var locked = xmlNode.Attributes["m:locked"];
if (locked != null && locked.Value == "true")
{
trgSegment.Properties.IsLocked = true;
}
// Check if target empty and look for alt-trans
if (trgSegment.Count == 0)
{
var alttrans = xmlNode.SelectSingleNode("x:alt-trans/x:target", nsmgr);
if (alttrans != null && !string.IsNullOrWhiteSpace(alttrans.InnerText))
{
PopulateSegment(trgSegment, alttrans, false);
var alttransOrigin = xmlNode.SelectSingleNode("x:alt-trans", nsmgr).Attributes["origin"];
if (alttransOrigin != null)
{
var origin = alttransOrigin.Value;
if (origin.Contains("machine") || origin.Contains("mt"))
{
tuOrg.OriginType = DefaultTranslationOrigin.MachineTranslation;
}
else if (origin.Contains("tm"))
{
tuOrg.OriginType = DefaultTranslationOrigin.TranslationMemory;
}
tuOrg.OriginSystem = origin;
}
}
}
paragraphUnit.Target.Add(trgSegment);
}
else
{
var singleNode = xmlNode.SelectSingleNode("x:source", nsmgr);
if (singleNode != null)
{
singleNode.InnerText = "";
}
ISegment trgSegment = CreateSegment(xmlNode.SelectSingleNode("x:source", nsmgr), segmentPairProperties, false);
paragraphUnit.Target.Add(trgSegment);
}
var transOrigin = xmlNode.Attributes["m:trans-origin"];
if (transOrigin.Value != null && transOrigin.Value != "null")
{
tuOrg.OriginType = transOrigin.Value;
}
segmentPairProperties.TranslationOrigin = tuOrg;
// Add comments
if (xmlNode.SelectSingleNode("m:comment", nsmgr) != null)
{
paragraphUnit.Properties.Comments = CreateComment(xmlNode.SelectSingleNode("m:comment", nsmgr));
}
}
// Clear any ids on the queue
tagIds.Clear();
units.Add(paragraphUnit);
}
return(units);
}
public static bool ContainsFuzzyMatch(ITranslationOrigin translationOrigin)
{
return(IsFuzzyMatch(translationOrigin));
}
public void SetUp()
{
_itemFactoryMock = A.Fake <IDocumentItemFactory>();
_propertiesFactoryMock = A.Fake <IPropertiesFactory>();
_paragraphUnitMock = A.Fake <IParagraphUnit>();
A.CallTo(() => _itemFactoryMock.CreateParagraphUnit(A <LockTypeFlags> .Ignored)).Returns(_paragraphUnitMock);
_paragraphSourceMock = A.Fake <IParagraph>();
A.CallTo(() => _paragraphUnitMock.Source).Returns(_paragraphSourceMock);
_paragraphTargetMock = A.Fake <IParagraph>();
A.CallTo(() => _paragraphUnitMock.Target).Returns(_paragraphTargetMock);
_segmentPairPropertiesMock = A.Fake <ISegmentPairProperties>();
A.CallTo(() => _itemFactoryMock.CreateSegmentPairProperties()).Returns(_segmentPairPropertiesMock);
_translationOriginMmock = A.Fake <ITranslationOrigin>();
A.CallTo(() => _itemFactoryMock.CreateTranslationOrigin()).Returns(_translationOriginMmock);
_sourceSegment0Mock = A.Fake <ISegment>();
_targetSegment0Mock = A.Fake <ISegment>();
_sourceSegment1Mock = A.Fake <ISegment>();
_targetSegment1Mock = A.Fake <ISegment>();
_sourceSegment2Mock = A.Fake <ISegment>();
_targetSegment2Mock = A.Fake <ISegment>();
_sourceSegment3Mock = A.Fake <ISegment>();
_targetSegment3Mock = A.Fake <ISegment>();
A.CallTo(() => _itemFactoryMock.CreateSegment(A <ISegmentPairProperties> .Ignored))
.ReturnsNextFromSequence(
_sourceSegment0Mock, _targetSegment0Mock,
_sourceSegment1Mock, _targetSegment1Mock,
_sourceSegment2Mock, _targetSegment2Mock,
_sourceSegment3Mock, _targetSegment3Mock
);
var textPropertiesMsgidMock = A.Fake <ITextProperties>();
A.CallTo(() => _propertiesFactoryMock.CreateTextProperties("message id")).Returns(textPropertiesMsgidMock);
var textPropertiesMsgidPluralMock = A.Fake <ITextProperties>();
A.CallTo(() => _propertiesFactoryMock.CreateTextProperties("message id plural"))
.Returns(textPropertiesMsgidPluralMock);
var textPropertiesMsgstrMock = A.Fake <ITextProperties>();
A.CallTo(() => _propertiesFactoryMock.CreateTextProperties("message string"))
.Returns(textPropertiesMsgstrMock);
var textPropertiesMsgstr0Mock = A.Fake <ITextProperties>();
A.CallTo(() => _propertiesFactoryMock.CreateTextProperties("message string 0"))
.Returns(textPropertiesMsgstr0Mock);
var textPropertiesMsgstr1Mock = A.Fake <ITextProperties>();
A.CallTo(() => _propertiesFactoryMock.CreateTextProperties("message string 1"))
.Returns(textPropertiesMsgstr1Mock);
var textPropertiesMsgstr2Mock = A.Fake <ITextProperties>();
A.CallTo(() => _propertiesFactoryMock.CreateTextProperties("message string 2"))
.Returns(textPropertiesMsgstr2Mock);
_textMsgidMock = A.Fake <IText>();
A.CallTo(() => _itemFactoryMock.CreateText(textPropertiesMsgidMock)).Returns(_textMsgidMock);
_textMsgidPluralMock = A.Fake <IText>();
A.CallTo(() => _itemFactoryMock.CreateText(textPropertiesMsgidPluralMock)).Returns(_textMsgidPluralMock);
_textMsgstrMock = A.Fake <IText>();
A.CallTo(() => _itemFactoryMock.CreateText(textPropertiesMsgstrMock)).Returns(_textMsgstrMock);
_textMsgstr0Mock = A.Fake <IText>();
A.CallTo(() => _itemFactoryMock.CreateText(textPropertiesMsgstr0Mock)).Returns(_textMsgstr0Mock);
_textMsgstr1Mock = A.Fake <IText>();
A.CallTo(() => _itemFactoryMock.CreateText(textPropertiesMsgstr1Mock)).Returns(_textMsgstr1Mock);
_textMsgstr2Mock = A.Fake <IText>();
A.CallTo(() => _itemFactoryMock.CreateText(textPropertiesMsgstr2Mock)).Returns(_textMsgstr2Mock);
}
private void AnonymizeComplete(ITranslationOrigin translationOrigin)
{
translationOrigin.OriginType = DefaultTranslationOrigin.Interactive;
translationOrigin.OriginSystem = string.Empty;
translationOrigin.MatchPercent = byte.Parse("0");
}
