/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/// <summary>compares 2 Generator objects</summary>
/// <param name="theOne">the One</param>
/// <param name="theOther">the Other</param>
/// <returns>true if identical </returns>
//////////////////////////////////////////////////////////////////////
public static bool IsGeneratorIdentical(AtomGenerator theOne, AtomGenerator theOther)
{
if (theOne == null && theOther == null)
{
return(true);
}
if (!ObjectModelHelper.IsBaseIdentical(theOne, theOther))
{
return(false);
}
if (String.Compare(theOne.Text, theOther.Text) != 0)
{
return(false);
}
if (String.Compare(theOne.Version, theOther.Version) != 0)
{
return(false);
}
if (AtomUri.Compare(theOne.Uri, theOther.Uri) != 0)
{
return(false);
}
return(true);
}
//============================================================
// CLASS SUMMARY
//============================================================
/// <summary>
/// Provides example code for the AtomGenerator class.
/// </summary>
public static void ClassExample()
{
#region AtomGenerator
AtomFeed feed = new AtomFeed();
feed.Id = new AtomId(new Uri("urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6"));
feed.Title = new AtomTextConstruct("Example Feed");
feed.UpdatedOn = new DateTime(2003, 12, 13, 18, 30, 2);
feed.Links.Add(new AtomLink(new Uri("http://example.org/")));
feed.Links.Add(new AtomLink(new Uri("/feed"), "self"));
feed.Authors.Add(new AtomPersonConstruct("John Doe"));
// Identify the software used to generate the feed
AtomGenerator generator = new AtomGenerator("Example Toolkit");
generator.Uri = new Uri("/myblog.php");
generator.Version = "1.0";
feed.Generator = generator;
AtomEntry entry = new AtomEntry();
entry.Id = new AtomId(new Uri("urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a"));
entry.Title = new AtomTextConstruct("Atom-Powered Robots Run Amok");
entry.UpdatedOn = new DateTime(2003, 12, 13, 18, 30, 2);
entry.Summary = new AtomTextConstruct("Some text.");
feed.AddEntry(entry);
#endregion
}
public void Create_a_simple_atom_feed_with_logo()
{
var feed = CreateSimpleFeed();
feed.Image = new Image(new Uri("http://www.dotnetgeek.de/logo.png"), "dotnetgeek feed", new Uri("http://www.dotnetgeek.de"));
var atomGenerator = new AtomGenerator(feed);
var feedXml = atomGenerator.Process();
const string expected = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
"<feed xmlns=\"http://www.w3.org/2005/Atom\">" +
"<title type=\"text\">dotnetgeek feed</title>" +
"<author><name>Daniel</name><email>[email protected]</email></author>" +
"<id>http://www.dotnetgeek.de/rss</id>" +
"<link rel=\"self\" type=\"application/rss+xml\" href=\"http://www.dotnetgeek.de/rss\" />" +
"<updated>2016-08-16T00:00:00Z</updated>" +
"<rights>2016 @ www.dotnetgeek.com</rights>" +
"<generator>dng.Syndication</generator>" +
"<subtitle type=\"text\">Dotnet relevant thinks</subtitle>" +
"<logo>http://www.dotnetgeek.de/logo.png</logo>" +
"<entry>" +
"<title>First Entry</title>" +
"<link href=\"http://www.dotnetgeek.com/first-entry\" />" +
"<id>http://www.dotnetgeek.com/first-entry</id>" +
"<summary>summary</summary>" +
"<content>Content</content>" +
"<author><name>Daniel</name><email>[email protected]</email></author>" +
"<published>2016-08-16T00:00:00Z</published>" +
"<updated>2016-08-16T00:00:00Z</updated>" +
"</entry>" +
"</feed>";
Assert.Equal(expected, feedXml);
}
public void AtomGeneratorConstructorTest1()
{
AtomGenerator target = new AtomGenerator();
Assert.IsNotNull(target);
Assert.IsTrue(String.IsNullOrEmpty(target.Text));
}
public void ShouldBePersistedTest()
{
AtomGenerator target = new AtomGenerator(); // TODO: Initialize to an appropriate value
target.Text = "dirty";
Assert.IsTrue(target.ShouldBePersisted());
}
public void AtomGeneratorConstructorTest()
{
string text = "test";
AtomGenerator target = new AtomGenerator(text);
Assert.AreEqual(text, target.Text);
}
public async Task WriteAsync(OutputFormatterWriteContext context)
{
using (var atomGenerator = new AtomGenerator(context.Object as Feed))
{
context.HttpContext.Response.ContentType = MediaTypes.AtomMediaType;
await context.HttpContext.Response.WriteAsync(atomGenerator.Process());
}
}
/// <summary>
/// Añade al XML un nodo identificando el generador del archivo Atom
/// </summary>
private void AddGenerator(MLNode parent, AtomGenerator generator)
{
MLNode node = parent.Nodes.Add(AtomConstTags.cnstStrChannelGenerator, generator.Name);
// Crea la cadena de atributos
node.Attributes.Add(AtomConstTags.cnstStrAttrURL, generator.URL);
node.Attributes.Add(AtomConstTags.cnstStrAttrVersion, generator.Version);
node.Attributes.Add(AtomConstTags.cnstStrAttrLanguage, generator.Language);
}
public void VersionTest()
{
AtomGenerator target = new AtomGenerator(); // TODO: Initialize to an appropriate value
string expected = "TestValue";
string actual;
target.Version = expected;
actual = target.Version;
Assert.AreEqual(expected, actual);
}
public void UriTest()
{
AtomGenerator target = new AtomGenerator(); // TODO: Initialize to an appropriate value
AtomUri expected = new AtomUri("http://www.test.com/");
AtomUri actual;
target.Uri = expected;
actual = target.Uri;
Assert.AreEqual(expected, actual);
}
public void GeneratorTest()
{
AtomSource target = new AtomSource(); // TODO: Initialize to an appropriate value
AtomGenerator expected = new AtomGenerator();
AtomGenerator actual;
target.Generator = expected;
actual = target.Generator;
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Creates a <see cref="AtomGenerator"/> using the supplied <see cref="XPathNavigator"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <returns>A <see cref="AtomGenerator"/> instance initialized using the supplied <paramref name="source"/>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a Atom 0.3 generator element.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static AtomGenerator CreateGenerator(XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
AtomGenerator generator = new AtomGenerator();
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract common attributes information
//------------------------------------------------------------
AtomUtility.FillCommonObjectAttributes(generator, source);
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
if (source.HasAttributes)
{
string urlAttribute = source.GetAttribute("url", String.Empty);
string versionAttribute = source.GetAttribute("version", String.Empty);
if (!String.IsNullOrEmpty(urlAttribute))
{
Uri uri;
if (Uri.TryCreate(urlAttribute, UriKind.RelativeOrAbsolute, out uri))
{
generator.Uri = uri;
}
}
if (!String.IsNullOrEmpty(versionAttribute))
{
generator.Version = versionAttribute;
}
}
if (!String.IsNullOrEmpty(source.Value))
{
generator.Content = source.Value;
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(generator, manager);
return(generator);
}
public override void WriteToStream(Type type, object value, Stream writeStream, HttpContent content)
{
if (!(value is Feed feed))
{
return;
}
using (var streamWriter = new StreamWriter(writeStream))
{
using (var atomGenerator = new AtomGenerator(feed))
{
streamWriter.WriteLine(atomGenerator.Process());
}
}
}
protected override IEnumerable<GeneratorResult> Generate()
{
var result = new AtomGenerator().Generate(
new GeneratorArguments<AtomGenerationTargetConfig>(
config: new AtomGenerationTargetConfig
{
Database = DatabaseName,
Host = Host,
InferrHiddenKey = InferrHiddenKey,
OutputPath = Output
},
atomsFolder: null,
defaults: null));
result.OutputPath = Output;
yield return result;
}
protected override IEnumerable <GeneratorResult> Generate()
{
var result = new AtomGenerator().Generate(
new GeneratorArguments <AtomGenerationTargetConfig>(
config: new AtomGenerationTargetConfig
{
Database = DatabaseName,
Host = Host,
InferrHiddenKey = InferrHiddenKey,
OutputPath = Output
},
atomsFolder: null,
defaults: null));
result.OutputPath = Output;
yield return(result);
}
public void Generates()
{
var results = new AtomGenerator().Generate(
new GeneratorArguments<AtomGenerationTargetConfig>(
new AtomGenerationTargetConfig
{
Host = ".",
Database = "AcoDomain"
},
atomsFolder: null,
defaults: null));
foreach (var item in results)
{
Console.WriteLine(item.FileName);
Console.WriteLine("=====");
Console.WriteLine(item.Output);
}
}
public void Generates()
{
var results = new AtomGenerator().Generate(
new GeneratorArguments <AtomGenerationTargetConfig>(
new AtomGenerationTargetConfig
{
Host = ".",
Database = "AcoDomain"
},
atomsFolder: null,
defaults: null));
foreach (var item in results)
{
Console.WriteLine(item.FileName);
Console.WriteLine("=====");
Console.WriteLine(item.Output);
}
}
public void SetInstructions(Interpreter interp, Program inInstructionList)
{
_randomGenerators.Clear();
for (int n = 0; n < inInstructionList.Size(); n++)
{
object o = inInstructionList.DeepPeek(n);
string name = null;
if (o is Instruction)
{
if (interp._instructions.Keys.Contains(o))
{
break;
}
}
else
{
if (o is string)
{
name = (string)o;
}
else
{
throw new Exception("Instruction list must contain a list of Push instruction names only");
}
}
// Check for registered
// I don't understand this "registered.X" bit.
if (name.IndexOf("registered.") == 0)
{
string registeredType = SharpenMinimal.Runtime.Substring(name, 11);
if (!registeredType.Equals("integer") &&
!registeredType.Equals("float") &&
!registeredType.Equals("boolean") &&
!registeredType.Equals("exec") &&
!registeredType.Equals("code") &&
!registeredType.Equals("name") &&
!registeredType.Equals("input")
// && !registeredType.Equals("frame")
)
{
Console.Error.WriteLine("Unknown instruction \"" + name + "\" in instruction set");
}
else
{
// Legal stack type, so add all generators matching
// registeredType to _randomGenerators.
// object[] keys = SharpenMinimal.Collections.ToArray(_instructions.Keys);
// for (int i = 0; i < keys.Length; i++)
// {
// string key = (string)keys[i];
foreach (string key in interp._instructions.Keys)
{
// So we're searching for anything with a type prefix.
if (key.IndexOf(registeredType) == 0)
{
AtomGenerator g = interp._generators[key];
_randomGenerators[key] = (g);
}
}
if (registeredType.Equals("boolean"))
{
var t = interp._generators["true"];
_randomGenerators["true"] = (t);
var f = interp._generators["false"];
_randomGenerators["false"] = (f);
}
if (registeredType.Equals("integer"))
{
var g = interp._generators["integer.erc"];
_randomGenerators["integer.erc"] = (g);
}
if (registeredType.Equals("float"))
{
var g = interp._generators["float.erc"];
_randomGenerators["float.erc"] = (g);
}
}
}
else
{
if (name.IndexOf("input.makeinputs") == 0)
{
string strnum = SharpenMinimal.Runtime.Substring(name, 16);
int num = System.Convert.ToInt32(strnum);
for (int i = 0; i < num; i++)
{
interp.DefineInstruction("input.in" + i, new InputInN(i));
var g = interp._generators["input.in" + i];
_randomGenerators["input.in" + i] = (g);
}
}
else
{
var g = interp._generators[name];
if (g == null)
{
throw new Exception("Unknown instruction \"" + name + "\" in instruction set");
}
else
{
_randomGenerators[name] = (g);
}
}
}
}
}
public void XmlNameTest()
{
AtomGenerator target = new AtomGenerator(); // TODO: Initialize to an appropriate value
Assert.AreEqual(AtomParserNameTable.XmlGeneratorElement, target.XmlName);
}
