private static string CalculateTagXml(IntermediateSection section, WixBundleTagSymbol tagSymbol)
{
var bundleSymbol = section.Symbols.OfType<WixBundleSymbol>().Single();
var uniqueId = Guid.Parse(bundleSymbol.BundleId).ToString("D");
var bundleVersion = TagWriter.CreateFourPartVersion(bundleSymbol.Version);
var packageTags = CollectPackageTags(section);
var licensed = (tagSymbol.Attributes == 1);
if (!Enum.TryParse(tagSymbol.Type, out TagType type))
{
type = TagType.Application;
}
var containedTags = CalculateContainedTagsAndType(packageTags, ref type);
using (var ms = new MemoryStream())
{
TagWriter.CreateTagFile(ms, tagSymbol.Regid, uniqueId.ToUpperInvariant(), bundleSymbol.Name, bundleVersion, bundleSymbol.Manufacturer, licensed, type, containedTags);
// Use StreamReader to "eat" the BOM if present.
ms.Position = 0;
using (var streamReader = new StreamReader(ms, Encoding.UTF8))
{
return streamReader.ReadToEnd();
}
}
}
protected void WriteTest <T, T2>(Func <Stream, T> createWriter, Func <Stream, T2> createReader)
where T : TagWriter where T2 : TagReader
{
// arrange
Stream stream = new MemoryStream();
var expected = CreateComplexData();
TagWriter target = createWriter(stream);
// act
target.WriteStartDocument();
target.WriteStartTag("Level", TagType.Compound);
target.WriteTag("longTest", 9223372036854775807);
target.WriteTag("shortTest", (short)32767);
target.WriteTag("stringTest", "HELLO WORLD THIS IS A TEST STRING ÅÄÖ!");
target.WriteTag("floatTest", (float)0.498231471);
target.WriteTag("intTest", 2147483647);
target.WriteStartTag("nested compound test", TagType.Compound);
target.WriteStartTag("ham", TagType.Compound);
target.WriteTag("name", "Hampus");
target.WriteTag("value", 0.75F);
target.WriteEndTag();
target.WriteStartTag("egg", TagType.Compound);
target.WriteTag("name", "Eggbert");
target.WriteTag("value", 0.5F);
target.WriteEndTag();
target.WriteEndTag();
target.WriteStartTag("listTest (long)", TagType.List, TagType.Long, 5);
target.WriteTag((long)11);
target.WriteTag((long)12);
target.WriteTag((long)13);
target.WriteTag((long)14);
target.WriteTag((long)15);
target.WriteEndTag();
target.WriteStartTag("listTest (compound)", TagType.List, TagType.Compound, 2);
target.WriteStartTag(TagType.Compound);
target.WriteTag("name", "Compound tag #0");
target.WriteTag("created-on", 1264099775885);
target.WriteEndTag();
target.WriteStartTag(TagType.Compound);
target.WriteTag("name", "Compound tag #1");
target.WriteTag("created-on", 1264099775885);
target.WriteEndTag();
target.WriteEndTag();
target.WriteTag("byteTest", (byte)127);
target.WriteTag(
"byteArrayTest (the first 1000 values of (n*n*255+n*7)%100, starting with n=0 (0, 62, 34, 16, 8, ...))",
ComplexData.SampleByteArray);
target.WriteTag("doubleTest", 0.49312871321823148);
target.WriteEndTag();
target.WriteEndDocument();
// assert
stream.Seek(0, SeekOrigin.Begin);
TagReader reader = createReader(stream);
var actual = reader.ReadDocument();
NbtAssert.Equal(expected, actual);
}
public void CreateWriter_throws_exception_for_null_stream()
{
// act
var e = Assert.Throws <ArgumentNullException>(() => TagWriter.CreateWriter(NbtFormat.Xml, null));
Assert.Equal($"Value cannot be null.{Environment.NewLine}Parameter name: stream", e.Message);
}
public void CreateWriter_returns_xml_writer()
{
// act
var target = TagWriter.CreateWriter(NbtFormat.Xml, new MemoryStream());
// assert
Assert.IsType <XmlTagWriter>(target);
}
public void CreateWriter_returns_binary_writer()
{
// act
var target = TagWriter.CreateWriter(NbtFormat.Binary, new MemoryStream());
// assert
Assert.IsType <BinaryTagWriter>(target);
}
private void SetupTagWriter()
{
Debug.WriteLine("Tag Writer set");
var ww = new TagWriter(Globals.ThisAddIn.Application.ActivePresentation.Tags);
ITagAdapter adap = new TagAdapter(ww);
_tagAdapter = adap;
}
public void CreateWriter_returns_xml_writer()
{
// arrange
TagWriter target;
// act
target = TagWriter.CreateWriter(NbtFormat.Xml, new MemoryStream());
// assert
Assert.IsInstanceOf <XmlTagWriter>(target);
}
public void CreateWriter_returns_binary_writer()
{
// arrange
TagWriter target;
// act
target = TagWriter.CreateWriter(NbtFormat.Binary, new MemoryStream());
// assert
Assert.IsInstanceOf <BinaryTagWriter>(target);
}
public void CreateWriter_throws_exception_for_unknown_type()
{
// act
var e = Assert.Throws <ArgumentOutOfRangeException>(
() => TagWriter.CreateWriter(NbtFormat.Unknown, new MemoryStream()));
Assert.Equal($"Invalid format.{Environment.NewLine}" +
$"Parameter name: format{Environment.NewLine}" +
"Actual value was Unknown.",
e.Message);
}
/// <summary>
/// Returns a <see cref="string"/> which represents the object instance.
/// </summary>
/// <returns>CAML-like string.</returns>
/// <example>
/// <![CDATA[<View>
/// <RowLimit></RowLimit>
/// <Query>
/// <Where></Where>
/// <OrderBy></OrderBy>
/// </Query>
/// <ViewFields></ViewFields>
/// </View>]]>
/// </example>
public override string ToString() {
var sb = new StringBuilder();
using (new TagWriter(Tags.View, sb)) {
TagWriter.Write(Tags.RowLimit, sb, RowLimit);
using (new TagWriter(Tags.Query, sb)) {
TagWriter.Write(Tags.Where, sb, Where);
TagWriter.Write(Tags.OrderBy, sb, OrderBys);
}
TagWriter.Write(Tags.ViewFields, sb, SelectableFields);
}
return sb.ToString();
}
protected void WriteDocumentTest <T, T2>(Func <Stream, T> createWriter, Func <Stream, T2> createReader)
where T : TagWriter where T2 : TagReader
{
// arrange
Stream stream = new MemoryStream();
var expected = CreateComplexData();
TagWriter target = createWriter(stream);
// act
target.WriteStartDocument();
target.WriteTag(expected);
target.WriteEndDocument();
// assert
stream.Seek(0, SeekOrigin.Begin);
TagReader reader = createReader(stream);
var actual = reader.ReadDocument();
NbtAssert.Equal(expected, actual);
}
public void CreateWriter_throws_exception_for_unknown_type()
{
// act
TagWriter.CreateWriter(NbtFormat.Unknown, new MemoryStream());
}
public void CreateWriter_throws_exception_for_null_stream()
{
// act
TagWriter.CreateWriter(NbtFormat.Xml, null);
}
private IEnumerable <SoftwareIdentificationTagSymbol> CreateProductTagFiles(IntermediateSection section)
{
var productTags = section.Symbols.OfType <WixProductTagSymbol>().ToList();
if (!productTags.Any())
{
return(null);
}
string productCode = null;
string productName = null;
string productVersion = null;
string manufacturer = null;
foreach (var property in section.Symbols.OfType <PropertySymbol>())
{
switch (property.Id.Id)
{
case "ProductCode":
productCode = property.Value;
break;
case "ProductName":
productName = property.Value;
break;
case "ProductVersion":
productVersion = TagWriter.CreateFourPartVersion(property.Value);
break;
case "Manufacturer":
manufacturer = property.Value;
break;
}
}
// If the ProductCode is available, only keep it if it is a GUID.
if (!String.IsNullOrEmpty(productCode))
{
if (productCode.Equals("*"))
{
productCode = null;
}
else if (Guid.TryParse(productCode, out var guid))
{
productCode = guid.ToString("D").ToUpperInvariant();
}
else // not a GUID, erase it.
{
productCode = null;
}
}
Directory.CreateDirectory(this.workingFolder);
var fileSymbols = section.Symbols.OfType <FileSymbol>().ToList();
var swidSymbols = new Dictionary <string, SoftwareIdentificationTagSymbol>();
foreach (var tagSymbol in productTags)
{
var tagFileRef = tagSymbol.FileRef;
var licensed = (tagSymbol.Attributes == 1);
var uniqueId = String.IsNullOrEmpty(productCode) ? tagSymbol.Name.Replace(" ", "-") : productCode;
if (!Enum.TryParse(tagSymbol.Type, out TagType type))
{
type = TagType.Application;
}
// Ensure all tag symbols in this product share a regid.
var firstTagSymbol = swidSymbols.Values.FirstOrDefault();
if (firstTagSymbol != null && firstTagSymbol.Regid != tagSymbol.Regid)
{
this.Messaging.Write(TagErrors.SingleRegIdPerProduct(tagSymbol.SourceLineNumbers, tagSymbol.Regid, firstTagSymbol.Regid, firstTagSymbol.SourceLineNumbers));
continue;
}
// Find the FileSymbol that is referenced by this WixProductTag.
var fileSymbol = fileSymbols.FirstOrDefault(f => f.Id.Id == tagFileRef);
if (fileSymbol != null)
{
var fileName = String.IsNullOrEmpty(fileSymbol.Name) ? Path.GetFileName(fileSymbol.Source.Path) : fileSymbol.Name;
// Write the tag file.
fileSymbol.Source = new IntermediateFieldPathValue
{
Path = Path.Combine(this.workingFolder, fileName)
};
this.backendHelper.TrackFile(fileSymbol.Source.Path, TrackedFileType.Temporary, fileSymbol.SourceLineNumbers);
using (var fs = new FileStream(fileSymbol.Source.Path, FileMode.Create))
{
TagWriter.CreateTagFile(fs, tagSymbol.Regid, uniqueId, productName, productVersion, manufacturer, licensed, type, null);
}
// Ensure the matching "SoftwareIdentificationTag" symbol exists and is populated correctly.
if (!swidSymbols.TryGetValue(tagFileRef, out var swidRow))
{
swidRow = new SoftwareIdentificationTagSymbol(fileSymbol.SourceLineNumbers)
{
FileRef = tagFileRef,
Regid = tagSymbol.Regid
};
swidSymbols.Add(tagFileRef, swidRow);
}
// Always rewrite.
swidRow.TagId = uniqueId;
swidRow.Type = type.ToString();
}
}
return(swidSymbols.Values);
}
