public void CompiledTransform_Transform_Message_Success()
{
var transformer = CompiledTransform.Compile(_transformMessage);
var result = transformer.Transform("{ Message: 'Hello, I am a message!', PastRegion: 'OR', FutureRegion: 'CA' }", null, null);
Assert.AreNotEqual(_transformMessage, result);
Assert.IsNotNull(JObject.Parse(result));
}
public void CompiledTransform_Transform_TryCatch_no_throw_Success()
{
var transformer = CompiledTransform.Compile(_transformTryCatchNoThrow);
var result = transformer.Transform("{ Message: 'Hello, I am an error!', PastRegion: 'OR', FutureRegion: 'CA' }", null, null);
var json = JObject.Parse(result);
Assert.AreEqual("Chevy", json["Driver"]["Make"]);
}
public void CompiledTransform_ParseElementParams_wFunction_Success()
{
var parms = CompiledTransform.ParseElementParams("foreach", "#foreach(sort(Customers, Name), Persons)", new List <bool> {
false, true
});
Assert.AreEqual(2, parms.Count);
Assert.IsTrue(parms[0] is IExpression);
Assert.AreEqual("Persons", parms[1].Evaluate(null).ToString());
}
public void CompiledTransform_Transform_TryCatch_errorcode2_Success()
{
var transformer = CompiledTransform.Compile(_transformTryCatch_errorcode2);
var result = transformer.Transform("{ Message: 'Hello, I am an error!', PastRegion: 'OR', FutureRegion: 'CA' }", null, Transformer.CompileFunctions(null));
var json = JObject.Parse(result);
Assert.AreEqual("Pontiac", json["Driver"]["Make"]);
}
public void CompiledTransform_Transform_IfElsifElse2_2Levels_Success()
{
var transformer = CompiledTransform.Compile(_transformElseIf2);
var result = transformer.Transform("{ Region: 'WA', CurrentRegion: 'WA', PastRegion: 'OR', FutureRegion: 'CA', Subregion: 'Seattle', CurrentSubregion: 'Bellevue' }", null, null);
Assert.AreNotEqual(_transformElseIf2, result);
Assert.IsNotNull(JObject.Parse(result));
var driver = JsonConvert.DeserializeObject <DriverContainer>(result);
Assert.AreEqual("Lance", driver.Driver.FirstName);
Assert.AreEqual("Boulder", driver.Driver.LastName);
}
public void CompiledTransform_Transform_IfElsifElse4_Success()
{
var transformer = CompiledTransform.Compile(_transformElseIf1);
var result = transformer.Transform("{ Region: 'ID', CurrentRegion: 'WA', PastRegion: 'OR', FutureRegion: 'CA' }", null, null);
Assert.AreNotEqual(_transformIf1, result);
Assert.IsNotNull(JObject.Parse(result));
var driver = JsonConvert.DeserializeObject <DriverContainer>(result);
Assert.AreEqual("Frank", driver.Driver.FirstName);
Assert.AreEqual("Sands", driver.Driver.LastName);
}
public void CompiledTransform_Transform_Variable_Object2_Success()
{
var transformer = CompiledTransform.Compile(_transformVariableObj2);
var result = transformer.Transform("{ }", null, null);
Assert.AreNotEqual(_transformVariableObj2, result);
var json = JObject.Parse(result);
Assert.IsNotNull(json);
Assert.AreEqual("RodrigoGuiterrez", json["Driver"]["Name"].ToString());
}
public void CompiledTransform_Transform_Variable2_Success()
{
var transformer = CompiledTransform.Compile(_transformVariable2);
var result = transformer.Transform("{ Region: 'WA', PastRegion: 'OR', FutureRegion: 'CA' }", null, null);
Assert.AreNotEqual(_transformVariable2, result);
Assert.IsNotNull(JObject.Parse(result));
var driver = JsonConvert.DeserializeObject <DriverContainer>(result);
Assert.AreEqual("Fred", driver.Driver.FirstName);
Assert.AreEqual("Flintstone", driver.Driver.LastName);
}
protected void LoadStylesheetFromReader(XmlReader reader, XsltSettings settings, XmlResolver resolver)
{
if (SupportCharacterMaps)
{
var cmr = new CharacterMappingXmlReader(reader);
CompiledTransform.Load(cmr, settings, resolver);
_characterMap = cmr.CompileCharacterMapping();
}
else
{
CompiledTransform.Load(reader, settings, resolver);
}
}
public void CompiledTransform_Transform_CopyOf2_Success()
{
var transformer = CompiledTransform.Compile(_transformCopyOf2);
var result = transformer.Transform(_dataCopyOf2, null, null);
Assert.AreNotEqual(_transformCopyOf2, result);
var jresult = JObject.Parse(result);
Assert.IsNotNull(jresult);
Assert.IsNotNull(jresult["Vehicles"]);
Assert.AreEqual("Chevy", jresult["Vehicles"][0]["Stuff"]["Make"]);
}
public void CompiledTransform_Transform_CopyOf4_Success()
{
var transformer = CompiledTransform.Compile(_transformCopyOf4);
var result = transformer.Transform(_dataCopyOf4, null, null);
Assert.AreNotEqual(_transformCopyOf4, result);
var jresult = JObject.Parse(result);
Assert.IsNotNull(jresult);
Assert.IsNotNull(jresult["output"]);
Assert.AreEqual("true", jresult["output"]["modified"].ToString().ToLower());
}
public void CompiledTransform_Transform_propnames2_Success()
{
var transformer = CompiledTransform.Compile(_transform2a);
var result = transformer.Transform(_data2, null, null);
Assert.AreNotEqual(_transform2a, result);
Assert.IsNotNull(JObject.Parse(result));
var car = JsonConvert.DeserializeObject <Automobile2>(result);
Assert.AreEqual("Chevy", car.Brand);
Assert.AreEqual("Corvette", car.Model);
Assert.AreEqual(1964, car.Year);
Assert.AreEqual("Blue", car.Color);
}
public void CompiledTransform_Transform_Bind_Success()
{
var transformer = CompiledTransform.Compile(_transform4);
var result = transformer.Transform(_data3, null, null);
Assert.AreNotEqual(_transform4, result);
Assert.IsNotNull(JObject.Parse(result));
var driver = JsonConvert.DeserializeObject <Driver>(result);
Assert.AreEqual("Chevy", driver.Car.Brand);
Assert.AreEqual("Corvette", driver.Car.Model);
Assert.AreEqual(1964, driver.Car.Year);
Assert.AreEqual("Blue", driver.Car.Color);
}
public void CompiledTransform_Transform_CopyOf_array2_Success()
{
var transformer = CompiledTransform.Compile(_transformCopyOf4);
var result = transformer.Transform(_dataCopyOf6, null, null);
Assert.AreNotEqual(_transformCopyOf4, result);
var jresult = JObject.Parse(result);
Assert.IsNotNull(jresult);
Assert.IsNotNull(jresult["output"]);
Assert.IsTrue(jresult["output"] is JArray);
Assert.AreEqual("Tomato", ((jresult["output"] as JArray)[0]["RedShades"] as JArray)[2].ToString());
}
public void CompiledTransform_Transform_CopyOf_Success()
{
var transformer = CompiledTransform.Compile(_transformCopyOf1);
var result = transformer.Transform(_dataCopyOf, null, null);
Assert.AreNotEqual(_transformCopyOf1, result);
var jresult = JObject.Parse(result);
Assert.IsNotNull(jresult);
Assert.IsNotNull(jresult["Invoice"]);
Assert.AreEqual(945, jresult["Invoice"]["Muffler"]);
Assert.AreEqual(123, jresult["Invoice"]["Sparkplugs"]);
Assert.AreEqual(77, jresult["Invoice"]["Solenoid"]);
}
public void CompiledTransform_Transform_If_Success()
{
var transformer = CompiledTransform.Compile(_transformIf1);
var result = transformer.Transform(_dataCarList, null, null);
Assert.AreNotEqual(_transformIf1, result);
Assert.IsNotNull(JObject.Parse(result));
var driver = JsonConvert.DeserializeObject <DriverContainer2>(result);
Assert.AreEqual(1, driver.Driver.Vehicles.Count);
Assert.AreEqual("Chevy", driver.Driver.Vehicles[0].Brand);
Assert.AreEqual("Corvette", driver.Driver.Vehicles[0].Model);
Assert.AreEqual(1964, driver.Driver.Vehicles[0].Year);
Assert.AreEqual("Blue", driver.Driver.Vehicles[0].Color);
}
public void CompiledTransform_Transform_CopyOf_expr_Success()
{
var transformer = CompiledTransform.Compile(_transformCopyOfExpr);
var result = transformer.Transform(_dataCopyOfExpr, null, null);
Assert.AreNotEqual(_transformCopyOfExpr, result);
var jresult = JObject.Parse(result);
Assert.IsNotNull(jresult);
var cars = jresult["Cars"] as JArray;
Assert.IsNotNull(cars);
Assert.AreEqual(2, cars.Count);
}
protected void TransformXPathNavigable(IXPathNavigable nav, XsltArgumentList args, XmlWriter xmlWriter, XmlResolver resolver)
{
var fieldInfo = CompiledTransform.GetType().GetField(
"command", BindingFlags.Instance | BindingFlags.NonPublic);
if (fieldInfo == null)
{
return;
}
var command = fieldInfo.GetValue(CompiledTransform);
var executeMethod = command.GetType().GetMethod("Execute", BindingFlags.Instance | BindingFlags.Public,
null, new[] { typeof(IXPathNavigable), typeof(XmlResolver), typeof(XsltArgumentList), typeof(XmlWriter) }, null);
executeMethod.Invoke(command,
new object[] { nav, resolver, AddExsltExtensionObjectsSync(args), xmlWriter });
}
public void CompiledTransform_Transform_simple_Success()
{
var transformer = CompiledTransform.Compile(_transform1);
var result = transformer.Transform(_data1, null, null);
Assert.AreNotEqual(_transform1, result);
Assert.IsNotNull(JObject.Parse(result));
var car = JsonConvert.DeserializeObject <Automobile>(result);
Assert.AreEqual("Chevy", car.Make);
Assert.AreEqual("Corvette", car.Model);
Assert.AreEqual(1964, car.Year);
Assert.AreEqual("Blue", car.Color);
Assert.IsNotNull(car.Engine);
Assert.AreEqual("375", car.Engine.Displacement);
}
public void CompiledTransform_Transform_CopyOf3_Success()
{
var transformer = CompiledTransform.Compile(_transformCopyOf3);
var result = transformer.Transform(_dataCopyOf3, null, null);
Assert.AreNotEqual(_transformCopyOf3, result);
var jresult = JObject.Parse(result);
Assert.IsNotNull(jresult);
Assert.IsNotNull(jresult["output"]);
var val = jresult["output"]["modified"].Value <DateTime>();
Assert.AreEqual("2016-07-04T17:00:00.0000000-07:00", val.ToString("o"));
}
public void CompiledTransform_Transform_if_wbool_Success()
{
var transformer = CompiledTransform.Compile(_transformIfBool);
var result = transformer.Transform(_dataIfBool, new TransformerContext {
Arguments = new Dictionary <string, object> {
{ "Licensed", true }, { "YearsDriven", 10 }, { "LicenseState", 7 }
}
}, null);
Assert.AreNotEqual(_transformIfBool, result);
var jresult = JObject.Parse(result);
Assert.IsNotNull(jresult);
Assert.IsNotNull(jresult["CanDrive"]);
Assert.AreEqual("true", jresult["CanDrive"].ToString().ToLower());
}
public void CompiledTransform_Transform_wArguments_Success()
{
var transformer = CompiledTransform.Compile(_transform5);
var result = transformer.Transform(_data3, new TransformerContext {
Arguments = new Dictionary <string, object> {
{ "CarMake", "Aston-Martin" }
}
}, null);
Assert.AreNotEqual(_transform5, result);
Assert.IsNotNull(JObject.Parse(result));
var driver = JsonConvert.DeserializeObject <Driver>(result);
Assert.AreEqual("Aston-Martin", driver.Car.Brand);
Assert.AreEqual("Corvette", driver.Car.Model);
Assert.AreEqual("1964", driver.Car.Year.ToString());
Assert.AreEqual("Blue", driver.Car.Color);
}
public void CompiledTransform_Transform_Throw_Success()
{
var transformer = CompiledTransform.Compile(_transformThrow);
try
{
transformer.Transform("{ Message: 'Hello, I am an error!', PastRegion: 'OR', FutureRegion: 'CA' }", null, null);
Assert.Fail("Test method did not throw expected exception JTran.Transformer+UserError.");
}
catch (Transformer.UserError ex)
{
Assert.AreEqual("Hello, I am an error!", ex.Message);
}
catch
{
Assert.Fail("Test method threw exception but it was not the expected typed of JTran.Transformer+UserError.");
}
}
public void CompiledTransform_Transform_function_position_Success()
{
var transformer = CompiledTransform.Compile(_transformForEach2);
var result = transformer.Transform(_dataCarList, null, Transformer.CompileFunctions(null));
Assert.AreNotEqual(_transformForEach1, result);
Assert.IsNotNull(JObject.Parse(result));
var driver = JsonConvert.DeserializeObject <DriverContainer2>(result);
Assert.AreEqual(3, driver.Driver.Vehicles.Count);
Assert.AreEqual("Chevy", driver.Driver.Vehicles[0].Brand);
Assert.AreEqual("Corvette", driver.Driver.Vehicles[0].Model);
Assert.AreEqual(1964, driver.Driver.Vehicles[0].Year);
Assert.AreEqual("Blue", driver.Driver.Vehicles[0].Color);
Assert.AreEqual(0, driver.Driver.Vehicles[0].Index);
Assert.AreEqual(1, driver.Driver.Vehicles[1].Index);
Assert.AreEqual(2, driver.Driver.Vehicles[2].Index);
}
public void CompiledTransform_Transform_document_Success()
{
var transformer = CompiledTransform.Compile(_transformDocument1);
var context = new TransformerContext();
var locations = "{ City: 'Granitesville', Region: 'Bedrock' }";
var repo = new DocumentRepository();
repo.Documents.Add("Default", locations);
context.DocumentRepositories.Add("Locations", repo);
var result = transformer.Transform("{ FirstName: 'Fred', LastName: 'Flintstone' }", context, Transformer.CompileFunctions(null));
Assert.AreNotEqual(_transformDocument1, result);
Assert.IsNotNull(JObject.Parse(result));
var person = JsonConvert.DeserializeObject <Person>(result);
Assert.AreEqual("Fred", person.FirstName);
Assert.AreEqual("Flintstone", person.LastName);
Assert.AreEqual("Granitesville", person.City);
Assert.AreEqual("Bedrock", person.Region);
}
protected void TransformToWriter(XmlInput defaultDocument, XsltArgumentList xsltArgs, XmlWriter targetWriter)
{
XmlWriter xmlWriter;
if (SupportCharacterMaps && _characterMap != null && _characterMap.Count > 0)
{
xmlWriter = new CharacterMappingXmlWriter(targetWriter, _characterMap);
}
else
{
xmlWriter = targetWriter;
}
if (EnforceXHtmlOutput)
{
xmlWriter = new XhtmlWriter(xmlWriter);
}
var args = AddExsltExtensionObjectsSync(xsltArgs);
var xmlReader = defaultDocument.Source as XmlReader;
if (xmlReader != null)
{
CompiledTransform.Transform(xmlReader, args, xmlWriter, defaultDocument.Resolver);
return;
}
var nav = defaultDocument.Source as IXPathNavigable;
if (nav != null)
{
if (defaultDocument.Resolver is DefaultXmlResolver)
{
CompiledTransform.Transform(nav, args, xmlWriter);
}
else
{
TransformXPathNavigable(nav, args, xmlWriter, defaultDocument.Resolver);
}
return;
}
var str = defaultDocument.Source as string;
if (str != null)
{
using (var reader = XmlReader.Create(str, GetReaderSettings(defaultDocument)))
{
CompiledTransform.Transform(reader, args, xmlWriter, defaultDocument.Resolver);
}
return;
}
var strm = defaultDocument.Source as Stream;
if (strm != null)
{
using (var reader = XmlReader.Create(strm, GetReaderSettings(defaultDocument)))
{
CompiledTransform.Transform(reader, args, xmlWriter, defaultDocument.Resolver);
}
return;
}
var txtReader = defaultDocument.Source as TextReader;
if (txtReader != null)
{
using (var reader = XmlReader.Create(txtReader, GetReaderSettings(defaultDocument)))
{
CompiledTransform.Transform(reader, args, xmlWriter, defaultDocument.Resolver);
}
return;
}
throw new Exception("Unexpected XmlInput");
}
