public void TooLongStringsTest(string variable)
{
var sb = new StringBuilder();
string input;
// Add some variables in the text to test a use case where we don't have only text
if (!string.IsNullOrEmpty(variable))
{
sb.Append(variable);
}
sb.Append('a', 45000);
// Add some variables in the text to test a use case where we don't have only text
if (!string.IsNullOrEmpty(variable))
{
sb.Append(variable);
}
input = sb.ToString();
IStore store = new SimpleStore();
store["foo"] = "{foo}";
var doc = new SimpleDocument(input);
var res = doc.Render(store);
Assert.AreEqual(input, res);
}
public void TestTemplateOneOf()
{
Random random = new Random();
var document = new SimpleDocument("The letter is {OneOf(\"a\", \"b\", \"c\", \"d\", null)}.");
var store = new BuiltinStore();
store["OneOf"] = new NativeFunction((values) =>
{
return values[random.Next(values.Count)];
});
store["system"] = "Alrai";
List<string> results = new List<string>();
for (int i = 0; i < 1000; i++)
{
results.Add(document.Render(store));
}
Assert.IsTrue(results.Contains(@"The letter is a."));
results.RemoveAll(result => result == @"The letter is a.");
Assert.IsTrue(results.Contains(@"The letter is b."));
results.RemoveAll(result => result == @"The letter is b.");
Assert.IsTrue(results.Contains(@"The letter is c."));
results.RemoveAll(result => result == @"The letter is c.");
Assert.IsTrue(results.Contains(@"The letter is d."));
results.RemoveAll(result => result == @"The letter is d.");
Assert.IsTrue(results.Contains(@"The letter is ."));
results.RemoveAll(result => result == @"The letter is .");
Assert.IsTrue(results.Count == 0);
}
private IDocument CreateDocumentFromFile(string file)
{
string[] lines;
try
{
lines = File.ReadAllLines(file);
}
catch (Exception ex)
{
Errors = string.Format("Error pre-parsing file: {0}.{1}{2}", file, Environment.NewLine, ex.Message);
return(null);
}
StringBuilder text = new StringBuilder();
foreach (string line in lines)
{
string textLine;
if (line.Contains("@project"))
{
textLine = line.Replace("@project", Name);
}
else
{
textLine = line;
}
if (textLine.Contains("@machine"))
{
foreach (BasicObjectsTree tree in Data.Trees)
{
text.AppendLine(textLine.Replace("@machine", tree.Name));
}
}
else
{
text.AppendLine(textLine);
}
}
IDocument document;
using (var stream = new MemoryStream(Encoding.ASCII.GetBytes(text.ToString())))
{
using (var reader = new StreamReader(stream, Encoding.UTF8))
{
try
{
document = new SimpleDocument(reader, pjSetting); // throws ParseException on error
}
catch (ParseException ex)
{
Errors = string.Format("Error parsing {3}:\r\nLine {0}, pos {1}: {2}", ex.Line, ex.Column, ex.Message, file);
ErrorLine = ex.Line;
ErrorColumn = ex.Column;
stream.Dispose();
return(null);
}
}
}
return(document);
}
public void TextTooLong(string variable, int characters)
{
var builder = new StringBuilder();
var store = new SimpleStore();
string input;
// Add some variables in the text to test a use case where we don't have only text
if (!string.IsNullOrEmpty(variable))
{
builder.Append(variable);
}
builder.Append('a', characters);
// Add some variables in the text to test a use case where we don't have only text
if (!string.IsNullOrEmpty(variable))
{
builder.Append(variable);
}
input = builder.ToString();
store["foo"] = "{foo}";
var document = new SimpleDocument(input);
var output = document.Render(store);
Assert.AreEqual(input, output);
}
protected override async Task <List <string> > Deserialize(string obj)
{
var simpleDocument = new SimpleDocument <List <string> >(obj);
var document = (List <string>)simpleDocument.Document;
return(await Task.FromResult(document));
}
public async Task Dispose_Blocks()
{
await using SearchResources resources = await SearchResources.CreateWithEmptyIndexAsync <SimpleDocument>(this);
SearchClient client = resources.GetSearchClient();
SimpleDocument[] data = SimpleDocument.GetDocuments((int)(BatchSize * 1.5));
await using SearchIndexingBufferedSender <SimpleDocument> indexer =
client.CreateIndexingBufferedSender(
new SearchIndexingBufferedSenderOptions <SimpleDocument>()
{
AutoFlush = false
});
AssertNoFailures(indexer);
ConcurrentDictionary <int, IndexDocumentsAction <SimpleDocument> > pending = TrackPending(indexer);
await indexer.UploadDocumentsAsync(data);
await DelayAsync(EventDelay, EventDelay);
Assert.AreEqual(data.Length, pending.Count);
await((IAsyncDisposable)indexer).DisposeAsync();
await WaitForDocumentCountAsync(resources.GetSearchClient(), data.Length);
}
public void TestTemplateOneOf()
{
Random random = new Random();
var document = new SimpleDocument("The letter is {OneOf(\"a\", \"b\", \"c\", \"d\", null)}.");
var store = new BuiltinStore();
store["OneOf"] = new NativeFunction((values) =>
{
return(values[random.Next(values.Count)]);
});
store["system"] = "Alrai";
List <string> results = new List <string>();
for (int i = 0; i < 1000; i++)
{
results.Add(document.Render(store));
}
Assert.IsTrue(results.Contains(@"The letter is a."));
results.RemoveAll(result => result == @"The letter is a.");
Assert.IsTrue(results.Contains(@"The letter is b."));
results.RemoveAll(result => result == @"The letter is b.");
Assert.IsTrue(results.Contains(@"The letter is c."));
results.RemoveAll(result => result == @"The letter is c.");
Assert.IsTrue(results.Contains(@"The letter is d."));
results.RemoveAll(result => result == @"The letter is d.");
Assert.IsTrue(results.Contains(@"The letter is ."));
results.RemoveAll(result => result == @"The letter is .");
Assert.IsTrue(results.Count == 0);
}
private void buttonEvaluate_Click(object sender, EventArgs e)
{
SimpleDocument document;
ISetting setting;
IStore store;
setting = this.SettingCreate();
try
{
document = new SimpleDocument(this.textBoxInput.Text, setting);
store = new BuiltinStore();
foreach (TreeNode root in this.treeViewValue.Nodes)
{
foreach (KeyValuePair <Value, Value> pair in this.ValuesBuild(root.Nodes))
{
store.Set(pair.Key, pair.Value, StoreMode.Global);
}
}
this.DisplayText(document.Render(store));
}
catch (ParseException exception)
{
this.DisplayError(exception);
}
}
private void buttonEvaluate_Click(object sender, EventArgs e)
{
SimpleDocument document;
ISetting setting;
IStore store;
setting = this.SettingCreate ();
try
{
document = new SimpleDocument (this.textBoxInput.Text, setting);
store = new BuiltinStore ();
foreach (TreeNode root in this.treeViewValue.Nodes)
{
foreach (KeyValuePair<Value, Value> pair in this.ValuesBuild (root.Nodes))
store.Set (pair.Key, pair.Value, StoreMode.Global);
}
this.DisplayText (document.Render (store));
}
catch (ParseException exception)
{
this.DisplayError (exception);
}
}
public async Task AutoFlush_PartialBatch()
{
await using SearchResources resources = await SearchResources.CreateWithEmptyIndexAsync <SimpleDocument>(this);
SearchClient client = resources.GetSearchClient();
SimpleDocument[] data = SimpleDocument.GetDocuments(BatchSize / 2);
await using SearchIndexingBufferedSender <SimpleDocument> indexer =
client.CreateIndexingBufferedSender(
new SearchIndexingBufferedSenderOptions <SimpleDocument>()
{
AutoFlushInterval = null
});
AssertNoFailures(indexer);
await indexer.UploadDocumentsAsync(data);
await DelayAsync(TimeSpan.FromSeconds(5), EventDelay);
Assert.Zero((int)await resources.GetSearchClient().GetDocumentCountAsync());
await indexer.FlushAsync();
await WaitForDocumentCountAsync(resources.GetSearchClient(), data.Length);
}
public async Task AutoFlush_MultipleBatches()
{
await using SearchResources resources = await SearchResources.CreateWithEmptyIndexAsync <SimpleDocument>(this);
SearchClient client = resources.GetSearchClient();
SimpleDocument[] data = SimpleDocument.GetDocuments((int)(BatchSize * 3.5));
await using SearchIndexingBufferedSender <SimpleDocument> indexer =
client.CreateIndexingBufferedSender(
new SearchIndexingBufferedSenderOptions <SimpleDocument>()
{
AutoFlushInterval = null
});
AssertNoFailures(indexer);
await indexer.UploadDocumentsAsync(data);
await DelayAsync(TimeSpan.FromSeconds(10), EventDelay);
await WaitForDocumentCountAsync(resources.GetSearchClient(), 3 *BatchSize, delay : TimeSpan.FromSeconds(5));
// Check that we have the correct number of documents
await indexer.FlushAsync();
await WaitForDocumentCountAsync(resources.GetSearchClient(), data.Length);
}
private static void AssertEqual(string expression, string expected)
{
IDocument document = new SimpleDocument("{eq(" + expression + ", " + expected + ")}");
IStore store = new BuiltinStore();
Assert.AreEqual("true", document.Render(store), "'{0}' doesn't evaluate to '{1}'", expression, expected);
}
public async Task KeyFieldAccessor_Custom()
{
await using SearchResources resources = await SearchResources.CreateWithEmptyIndexAsync <SimpleDocument>(this);
SearchClient client = resources.GetSearchClient();
SimpleDocument[] data = SimpleDocument.GetDocuments(10);
bool customAccessorInvoked = false;
await using SearchIndexingBufferedSender <SimpleDocument> indexer =
client.CreateIndexingBufferedSender <SimpleDocument>(
new SearchIndexingBufferedSenderOptions <SimpleDocument>
{
KeyFieldAccessor = (SimpleDocument doc) =>
{
customAccessorInvoked = true;
return(doc.Id);
}
});
AssertNoFailures(indexer);
await indexer.UploadDocumentsAsync(data);
await indexer.FlushAsync();
await WaitForDocumentCountAsync(resources.GetSearchClient(), data.Length);
Assert.IsTrue(customAccessorInvoked);
}
public async Task Champion_ContinueAddingWhileSending()
{
await using SearchResources resources = await SearchResources.CreateWithEmptyIndexAsync <SimpleDocument>(this);
SearchClient client = resources.GetSearchClient();
SimpleDocument[] data = SimpleDocument.GetDocuments(1000);
// Wrap in a block so we DisposeAsync before getting the Count below
{
await using SearchIndexingBufferedSender <SimpleDocument> indexer =
client.CreateIndexingBufferedSender <SimpleDocument>();
AssertNoFailures(indexer);
// Trickle documents in
for (int i = 0; i < data.Length; i++)
{
await indexer.UploadDocumentsAsync(new[] { data[i] });
await DelayAsync(TimeSpan.FromMilliseconds(5));
}
}
// Check that we have the correct number of documents
await WaitForDocumentCountAsync(resources.GetSearchClient(), data.Length);
}
public async Task Behavior_Retry(int status)
{
await using SearchResources resources = await SearchResources.CreateWithEmptyIndexAsync <SimpleDocument>(this);
BatchingSearchClient client = GetBatchingSearchClient(resources);
SimpleDocument[] data = SimpleDocument.GetDocuments(1);
await using SearchIndexingBufferedSender <SimpleDocument> indexer =
client.CreateIndexingBufferedSender <SimpleDocument>();
client.ResponseTransformer = (IndexingResult result) =>
{
client.ResponseTransformer = null;
return(new IndexingResult(result.Key, false, status));
};
AssertNoFailures(indexer);
int sent = 0;
indexer.ActionSentAsync += (a, c) => { sent++; return(Task.CompletedTask); };
await indexer.UploadDocumentsAsync(data);
await indexer.FlushAsync();
Assert.Less(1, sent);
}
private static void AssertPrint(string expression, string expected)
{
IDocument document = new SimpleDocument("{echo " + expression + "}");
IStore store = new BuiltinStore();
Assert.AreEqual(expected, document.Render(store), "'{0}' doesn't render to '{1}'", expression, expected);
}
protected override string Serialize(Token accessToken)
{
var tokenHandle = accessToken.ToTokenHandle();
var document = new SimpleDocument <TokenHandle>(tokenHandle).DocumentJson;
return(document);
}
public async Task AutoFlushInterval_FullBatch()
{
await using SearchResources resources = await SearchResources.CreateWithEmptyIndexAsync <SimpleDocument>(this);
BatchingSearchClient client = GetBatchingSearchClient(resources);
SimpleDocument[] data = SimpleDocument.GetDocuments((int)(BatchSize * 1.5));
await using SearchIndexingBufferedSender <SimpleDocument> indexer =
client.CreateIndexingBufferedSender(
new SearchIndexingBufferedSenderOptions <SimpleDocument>
{
AutoFlushInterval = TimeSpan.FromMilliseconds(500)
});
AssertNoFailures(indexer);
ConcurrentDictionary <int, IndexDocumentsAction <SimpleDocument> > pending = TrackPending(indexer);
Task <object> submitted = client.BatchSubmitted;
await indexer.UploadDocumentsAsync(data);
await submitted;
await DelayAsync(EventDelay, EventDelay);
Assert.AreEqual(data.Length - BatchSize, pending.Count);
await DelayAsync(TimeSpan.FromSeconds(5), EventDelay);
await WaitForDocumentCountAsync(resources.GetSearchClient(), data.Length);
}
public virtual string GetHtml()
{
if (HtmlTemplate == null)
{
return(null);
}
var document = new SimpleDocument(HtmlTemplate);
var store = new BuiltinStore();
foreach (var prop in TemplateModel.GetType().GetProperties())
{
store[prop.Name] = prop.GetValue(TemplateModel).ToString();
}
var body = document.Render(store);
var baseDocument = new SimpleDocument(BaseHtmlTemplate);
store = new BuiltinStore
{
["Body"] = body
};
var result = baseDocument.Render(store);
return(result);
}
private static void AssertResult(string expression, bool expected)
{
IDocument document = new SimpleDocument("{" + (expected ? "" : "!") + "(" + expression + ")}");
IStore store = new BuiltinStore();
Assert.AreEqual("true", document.Render(store));
}
private IDocument CreateDocument(string templateText, RenderingContext context)
{
// Render cottle
IDocument document;
using (var stream = new MemoryStream(Encoding.ASCII.GetBytes(templateText)))
{
using (var reader = new StreamReader(stream, Encoding.UTF8))
{
try
{
document = new SimpleDocument(reader, pjSetting); // throws ParseException on error
}
catch (ParseException ex)
{
Errors = string.Format("Error parsing:\r\nLine {0}, pos {1}: {2}", ex.Line, ex.Column, ex.Message);
ErrorLine = ex.Line;
ErrorColumn = ex.Column;
stream.Dispose();
return(null);
}
}
}
return(document);
}
public override string ProcessData(string data)
{
string targetFileName = base.GetParam((int)ConfigurationEnum.DestinationPath).Value;
XDocument xdoc = null;
string serializedDoc = null;
SimpleDocument doc = null;
try
{
xdoc = XDocument.Parse(data);
List <XNode> list = new List <XNode>(xdoc.Root.Nodes());
Predicate <XNode> titleFinder = (XNode p) => { return(((System.Xml.Linq.XElement)p).Name == "title"); };
Predicate <XNode> textFinder = (XNode p) => { return(((System.Xml.Linq.XElement)p).Name == "text"); };
if (!(list.Exists(titleFinder) && list.Exists(textFinder)))
{
throw new ParseDataExceptionJW(new Exception("JsonWriterProvider: node 'title'or node 'text' not exists."));
}
doc = new SimpleDocument
{
Title = xdoc.Root.Element("title").Value,
Text = xdoc.Root.Element("text").Value
};
}
catch (Exception ex)
{
throw new ParseDataExceptionJW(ex);
}
try
{
serializedDoc = JsonConvert.SerializeObject(doc);
}
catch (Exception ex)
{
throw new SerializeExceptionJW(ex);
}
try
{
using (var targetStream = File.Open(targetFileName, FileMode.Create, FileAccess.Write))
{
var sw = new StreamWriter(targetStream);
sw.Write(serializedDoc);
sw.Flush();
}
}
catch (Exception ex)
{
throw new StreamExceptionJW(ex);
}
return(string.Empty);
// sw.Write(serializedDoc);
}
public override IEnumerable <string> DeserializeScopes(string obj)
{
obj = string.IsNullOrEmpty(obj) ? "[]" : obj;
var simpleDocument = new SimpleDocument <List <string> >(obj);
var document = (List <string>)simpleDocument.Document;
return(document);
}
public void TestTemplateSimple()
{
var document = new SimpleDocument(@"Hello {name}!");
var store = new BuiltinStore();
store["name"] = "world";
var result = document.Render(store);
Assert.AreEqual("Hello world!", result);
}
public override async Task <List <Secret> > DeserializeSecretsAsync(string obj)
{
obj = string.IsNullOrEmpty(obj) ? "[]" : obj;
var simpleDocument = new SimpleDocument <List <Secret> >(obj);
var document = (List <Secret>)simpleDocument.Document;
return(await Task.FromResult(document));
}
public override async Task <Token> DeserializeTokenHandleAsync(string obj, IClientStore clientStore)
{
var simpleDocument = new SimpleDocument <TokenHandle>(obj);
var document = (TokenHandle)simpleDocument.Document;
var result = await document.MakeIdentityServerTokenAsync(clientStore);
return(result);
}
public async Task Champion_BasicCheckpointing()
{
await using SearchResources resources = await SearchResources.CreateWithEmptyIndexAsync <SimpleDocument>(this);
SearchClient client = resources.GetSearchClient();
SimpleDocument[] data = SimpleDocument.GetDocuments(1000);
await using SearchIndexingBufferedSender <SimpleDocument> indexer =
client.CreateIndexingBufferedSender(
new SearchIndexingBufferedSenderOptions <SimpleDocument>
{
AutoFlush = true,
AutoFlushInterval = null
});
List <IndexDocumentsAction <SimpleDocument> > pending = new List <IndexDocumentsAction <SimpleDocument> >();
indexer.ActionAddedAsync +=
(IndexDocumentsAction <SimpleDocument> doc, CancellationToken cancellationToken) =>
{
pending.Add(doc);
return(Task.CompletedTask);
};
indexer.ActionCompletedAsync +=
(IndexDocumentsAction <SimpleDocument> doc,
IndexingResult result,
CancellationToken cancellationToken) =>
{
pending.Remove(doc);
return(Task.CompletedTask);
};
indexer.ActionFailedAsync +=
(IndexDocumentsAction <SimpleDocument> doc,
IndexingResult result,
Exception ex,
CancellationToken cancellationToken) =>
{
pending.Remove(doc);
return(Task.CompletedTask);
};
await indexer.UploadDocumentsAsync(data.Take(500));
await indexer.MergeDocumentsAsync(new[] { new SimpleDocument {
Id = "Fake"
} });
await indexer.UploadDocumentsAsync(data.Skip(500));
await DelayAsync(TimeSpan.FromSeconds(5), TimeSpan.FromMilliseconds(250));
Assert.AreEqual(1001 - BatchSize, pending.Count);
await indexer.FlushAsync();
Assert.AreEqual(0, pending.Count);
}
public override async Task <List <Claim> > DeserializeClaimsAsync(string obj)
{
obj = string.IsNullOrEmpty(obj) ? "[]" : obj;
var simpleDocument = new SimpleDocument <List <ClaimTypeRecord> >(obj);
var document = (List <ClaimTypeRecord>)simpleDocument.Document;
var result = document.ToClaims();
return(await Task.FromResult(result));
}
public override ClaimsPrincipal DeserializeSubject(string obj)
{
obj = string.IsNullOrEmpty(obj) ? "[]" : obj;
var simpleDocument = new SimpleDocument <List <ClaimIdentityRecord> >(obj);
var document = (List <ClaimIdentityRecord>)simpleDocument.Document;
var claimsPrincipal = new ClaimsPrincipal();
claimsPrincipal.AddIdentities(document.ToClaimsIdentitys());
return(claimsPrincipal);
}
public override string Serialize(IEnumerable <string> scopes)
{
if (scopes == null)
{
return("[]");
}
var simpleDocument = new SimpleDocument <IEnumerable <string> >(scopes).DocumentJson;
return(simpleDocument);
}
public void TestTemplateSimple()
{
var document = new SimpleDocument(@"Hello {name}!");
var store = new BuiltinStore();
store["name"] = "world";
var result = document.Render(store);
Assert.AreEqual("Hello world!", result);
}
public override string SerializeClaimsIdentityRecords(List <ClaimIdentityRecord> claimIdentityRecords)
{
if (claimIdentityRecords == null)
{
return("[]");
}
var simpleDocument = new SimpleDocument <List <ClaimIdentityRecord> >(claimIdentityRecords).DocumentJson;
return(simpleDocument);
}
public override string SerializeRequestScopes(List <string> scopeNames)
{
if (scopeNames == null)
{
return("[]");
}
var simpleDocument = new SimpleDocument <List <string> >(scopeNames).DocumentJson;
return(simpleDocument);
}
public void TestTemplateFunctional()
{
var document = new SimpleDocument(@"You are entering the {System(system)} system.");
var store = new BuiltinStore();
store["System"] = new NativeFunction((values) =>
{
return Translations.StarSystem(values[0].AsString);
}, 1);
store["system"] = "Alrai";
var result = document.Render(store);
Assert.AreEqual("You are entering the <phoneme alphabet=\"ipa\" ph=\"ˈalraɪ\">Alrai</phoneme> system.", result);
}
public void TestTemplateConditional()
{
var document = new SimpleDocument("{if value = 1:foo|else:{if value = 2:bar|else:baz}}");
var store = new BuiltinStore();
store["value"] = 1;
var result = document.Render(store);
Assert.AreEqual("foo", result);
store["value"] = 2;
result = document.Render(store);
Assert.AreEqual("bar", result);
store["value"] = 3;
result = document.Render(store);
Assert.AreEqual("baz", result);
}
/// <summary>
/// Resolve a script with an existing store
/// </summary>
public string resolveScript(string script, BuiltinStore store)
{
try
{
var document = new SimpleDocument(script, setting);
var result = document.Render(store);
Logging.Debug("Turned script " + script + " in to speech " + result);
return result.Trim() == "" ? null : result.Trim();
}
catch (Exception e)
{
Logging.Warn("Failed to resolve script: " + e.ToString());
return "There is a problem with the script: " + e.Message.Replace("'", "");
}
}
private void buttonClean_Click(object sender, EventArgs e)
{
SimpleDocument document;
ISetting setting;
setting = this.SettingCreate ();
try
{
document = new SimpleDocument (this.textBoxInput.Text, setting);
this.DisplayText (document.Source ());
}
catch (ParseException exception)
{
this.DisplayError (exception);
}
}
private static void AssertEqual(string expression, string expected)
{
IDocument document = new SimpleDocument ("{eq(" + expression + ", " + expected + ")}");
IStore store = new BuiltinStore ();
Assert.AreEqual ("true", document.Render (store), "'{0}' doesn't evaluate to '{1}'", expression, expected);
}
private static void AssertPrint(string expression, string expected)
{
IDocument document = new SimpleDocument ("{echo " + expression + "}");
IStore store = new BuiltinStore ();
Assert.AreEqual (expected, document.Render (store), "'{0}' doesn't render to '{1}'", expression, expected);
}
public string CreateDocument()
{
IDocument document;
IScope scope;
using (StreamReader template = new StreamReader(new FileStream("template.html", FileMode.Open), Encoding.UTF8))
{
document = new SimpleDocument(template);
}
scope = new DefaultScope();
scope["slideTitle"] = titleTextBox.Text;
int numExts = extensionsListBox.SelectedItems.Count;
var stylesheets = new Value[numExts];
var scripts = new Value[numExts];
var extSnippets = new Dictionary<Value, Value>();
int i = 0;
foreach (string extName in extensionsListBox.SelectedItems)
{
stylesheets[i] = extensions[extName] + ".css";
scripts[i] = extensions[extName] + ".js";
var snippetName = "deck." + extName;
if (snippets.ContainsKey(snippetName))
extSnippets.Add(snippetName, snippets[snippetName]);
i++;
}
scope["extensionStylesheets"] = stylesheets;
scope["extensionScripts"] = scripts;
scope["extensionSnippets"] = extSnippets;
scope["styleTheme"] = styles[(string)stylesListBox.SelectedItem];
scope["transitionTheme"] = transitions[(string)transitionsListBox.SelectedItem];
return document.Render(scope);
}
private static void AssertResult(string expression, bool expected)
{
IDocument document = new SimpleDocument ("{" + (expected ? "" : "!") + "(" + expression + ")}");
IStore store = new BuiltinStore ();
Assert.AreEqual ("true", document.Render (store));
}
