public void ToString_SomeShortcutJsonString_ProperJsonString()
{
var subject = new JsonString("{'str' : 'value', 'number': 42}");
string json = subject.ToString();
Assert.That(json, Is.EqualTo("{\"str\" : \"value\", \"number\": 42}"));
}
public void ctor_string()
{
const string expected = "Example";
var actual = new JsonString(expected).Value;
Assert.Equal(expected, actual);
}
public void ctor_string_DateTime()
{
var expected = new DateTime(2011, 7, 14, 19, 43, 37);
var actual = new JsonString(expected).ToDateTime();
Assert.Equal(expected, actual);
}
[InlineData("\\/Date(1310672617000)\\/")] // .NET
public void op_ToDateTime(string value)
{
var expected = new DateTime(2011, 7, 14, 19, 43, 37, DateTimeKind.Utc);
var actual = new JsonString(value).ToDateTime();
Assert.Equal(expected, actual);
}
public void Ctor_EmptyString_EmptyJsonString()
{
var subject = new JsonString(string.Empty);
Assert.That(subject.ToString(), Is.Empty);
string @null = subject;
Assert.That(@null, Is.Empty);
}
public void Ctor_NullString_NullJsonString()
{
var subject = new JsonString(null);
Assert.That(subject.ToString(), Is.Null);
string @null = subject;
Assert.That(@null, Is.Null);
}
public void CanStringifyUnicode(string escaped, string unicode)
{
// arrange
var token = new JsonString(unicode);
// act
var output = token.Stringify();
// assert
Assert.Equal(escaped, output);
}
private EquipmentSettings ReadCap3Point(XmlNode root)
{
var result = new EquipmentSettings(typeof(TrackerProperty));
int streamNo = 0;
foreach (XmlNode node in root.ChildNodes)
{
if (node.Name.Equals("Stream"))
{
int stream = JsonString.ParseInt(node.InnerText, -1);
if (stream < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.Stream0 + streamNo, stream);
streamNo += 1;
}
else if (node.Name.Equals("Model"))
{
int model = JsonString.ParseInt(node.InnerText, -1);
if (model < 0)
{
return(null);
}
// TODO replace with another system
//result.SetInteger(TrackerProperty.Model, model);
}
else if (node.Name.Equals("Smoothing"))
{
int smoothing = JsonString.ParseInt(node.InnerText, -1);
if (smoothing < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.Smoothing, smoothing);
}
else if (node.Name.Equals("SmoothingDropoff"))
{
decimal dropoff = JsonString.ParseDecimal(node.InnerText, -1.0m);
if (dropoff == -1.0m)
{
return(null);
}
result.SetDecimal(TrackerProperty.SmoothingDropoff, dropoff);
}
else if (node.Name.Equals("MinBrightness"))
{
int brightness = JsonString.ParseInt(node.InnerText, -1);
if (brightness < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MinBrightness, brightness);
}
else if (node.Name.Equals("MinClusterRadius"))
{
int radius = JsonString.ParseInt(node.InnerText, -1);
if (radius < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MinClusterRadius, radius);
}
else if (node.Name.Equals("MaxClusterRadius"))
{
int radius = JsonString.ParseInt(node.InnerText, -1);
if (radius < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MaxClusterRadius, radius);
}
else if (node.Name.Equals("MinLayerEnergy"))
{
int energy = JsonString.ParseInt(node.InnerText, -1);
if (energy < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MinLayerEnergy, energy);
}
else if (node.Name.Equals("MaxClusterMembers"))
{
int members = JsonString.ParseInt(node.InnerText, -1);
if (members < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MaxClusterMembers, members);
}
else if (node.Name.Equals("MaxClusters"))
{
int clusters = JsonString.ParseInt(node.InnerText, -1);
if (clusters < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MaxClusterNo, clusters);
}
else if (node.Name.Equals("MaxPoints"))
{
int points = JsonString.ParseInt(node.InnerText, -1);
if (points < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MaxPointNo, points);
}
else if (node.Name.Equals("Labels"))
{
int labelNo = JsonString.ParseInt(node.InnerText, -1);
if (labelNo < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.LabelNo, labelNo);
}
else if (node.Name.Equals("FastApproxThreshold"))
{
int threshold = JsonString.ParseInt(node.InnerText, -1);
if (threshold < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.FastApproxThreshold, threshold);
}
else if (node.Name.Equals("MaxQueuedImages"))
{
int images = JsonString.ParseInt(node.InnerText, -1);
if (images < 0)
{
return(null);
}
result.SetInteger(TrackerProperty.MaxQueuedImages, images);
}
}
return(result);
}
public TomlObject ReadRoot()
{
var doc = new TomlObject();
JsonObject scope = doc;
reader.Next(); // Read the first character
while (!reader.IsEof)
{
reader.SkipWhitespace();
if (reader.IsEof) break;
if (reader.Current == '#')
{
ReadComment();
continue;
}
// New scope
if (reader.Current == '[')
{
reader.Next(); // Read [
var name = ReadName();
if (reader.Current == ']') reader.Next();
var parts = name.Split('.');
scope = doc; // Reset scope to document
foreach (var part in parts)
{
if (scope.ContainsKey(part))
{
scope = (JsonObject)scope[part];
}
else
{
var newScope = new JsonObject();
scope.Add(part, newScope);
scope = newScope;
}
}
reader.SkipWhitespace();
continue;
}
var key = ReadName();
reader.SkipWhitespace();
JsonNode value = null;
reader.Next(); // Read =
reader.SkipWhitespace();
if (reader.Current == '"')
{
value = new JsonString(ReadQuotedString());
}
else if (reader.Current == '[')
{
value = ReadArray();
}
else
{
// Number or date literal
value = new JsonString(ReadName());
}
scope.Add(key, value);
}
return doc;
}
public static void BatchCreateArtistFont()
{
string dirName = "";
string fntname = EditorUtils.SelectObjectPathInfo(ref dirName).Split('.')[0];
Debug.Log(fntname);
Debug.Log(dirName);
string fntFileName = dirName + fntname + ".fnt";
Font CustomFont = new Font();
{
AssetDatabase.CreateAsset(CustomFont, dirName + fntname + ".fontsettings");
AssetDatabase.SaveAssets();
}
TextAsset BMFontText = null;
{
BMFontText = AssetDatabase.LoadAssetAtPath(fntFileName, typeof(TextAsset)) as TextAsset;
}
//Debug.Log(BMFontText.ToString().Replace("\"", "\'"));
Debug.Log(BMFontText.text);
JsonString js = JsonMapper.ToObject <JsonString>(BMFontText.text);
//JsonString js = JsonUtility.FromJson<JsonString>(BMFontText.text);
Debug.Log(js.file);
BMFont mbFont = new BMFont();
BMFontReader.Load(mbFont, BMFontText.name, BMFontText.bytes); // 借用NGUI封装的读取类
CharacterInfo[] characterInfo = new CharacterInfo[mbFont.glyphs.Count];
for (int i = 0; i < mbFont.glyphs.Count; i++)
{
BMGlyph bmInfo = mbFont.glyphs[i];
CharacterInfo info = new CharacterInfo();
info.index = bmInfo.index;
Rect r = new Rect();
r.x = (float)bmInfo.x / (float)mbFont.texWidth;
r.y = 1 - (float)bmInfo.y / (float)mbFont.texHeight;
r.width = (float)bmInfo.width / (float)mbFont.texWidth;
r.height = -1f * (float)bmInfo.height / (float)mbFont.texHeight;
info.uvBottomLeft = new Vector2(r.xMin, r.yMin);
info.uvBottomRight = new Vector2(r.xMax, r.yMin);
info.uvTopLeft = new Vector2(r.xMin, r.yMax);
info.uvTopRight = new Vector2(r.xMax, r.yMax);
//info.uv.x = (float)bmInfo.x / (float)mbFont.texWidth;
//info.uv.y = 1 - (float)bmInfo.y / (float)mbFont.texHeight;
//info.uv.width = (float)bmInfo.width / (float)mbFont.texWidth;
//info.uv.height = -1f * (float)bmInfo.height / (float)mbFont.texHeight;
r.x = (float)bmInfo.offsetX;
r.y = (float)bmInfo.offsetY;
r.width = (float)bmInfo.width;
r.height = (float)bmInfo.height;
//info.vert.x = (float)bmInfo.offsetX;
//info.vert.y = (float)bmInfo.offsetY;
//info.vert.width = (float)bmInfo.width;
//info.vert.height = (float)bmInfo.height;
info.minX = (int)r.xMin;
info.maxX = (int)r.xMax;
info.minY = (int)r.yMax;
info.maxY = (int)r.yMin;
info.advance = (int)bmInfo.advance;
characterInfo[i] = info;
}
CustomFont.characterInfo = characterInfo;
string textureFilename = dirName + mbFont.spriteName + ".png";
Material mat = null;
{
Shader shader = Shader.Find("Transparent/Diffuse");
mat = new Material(shader);
Texture tex = AssetDatabase.LoadAssetAtPath(textureFilename, typeof(Texture)) as Texture;
mat.SetTexture("_MainTex", tex);
AssetDatabase.CreateAsset(mat, dirName + fntname + ".mat");
AssetDatabase.SaveAssets();
}
CustomFont.material = mat;
}
private static void PopulateDependencies(
string projectPath,
IList <LibraryDependency> results,
JsonObject settings,
string propertyName,
bool isGacOrFrameworkReference)
{
var dependencies = settings.ValueAsJsonObject(propertyName);
if (dependencies != null)
{
foreach (var dependencyKey in dependencies.Keys)
{
if (string.IsNullOrEmpty(dependencyKey))
{
throw FileFormatException.Create(
"Unable to resolve dependency ''.",
dependencies.Value(dependencyKey),
projectPath);
}
var dependencyValue = dependencies.Value(dependencyKey);
var dependencyTypeValue = LibraryDependencyType.Default;
JsonString dependencyVersionAsString = null;
string target = null;
if (dependencyValue is JsonObject)
{
// "dependencies" : { "Name" : { "version": "1.0", "type": "build", "target": "project" } }
var dependencyValueAsObject = (JsonObject)dependencyValue;
dependencyVersionAsString = dependencyValueAsObject.ValueAsString("version");
// Remove support for flags (we only support build and nothing right now)
var type = dependencyValueAsObject.ValueAsString("type");
if (type != null)
{
dependencyTypeValue = LibraryDependencyType.Parse(type.Value);
}
// Read the target if specified
target = dependencyValueAsObject.ValueAsString("target")?.Value;
}
else if (dependencyValue is JsonString)
{
// "dependencies" : { "Name" : "1.0" }
dependencyVersionAsString = (JsonString)dependencyValue;
}
else
{
throw FileFormatException.Create(
string.Format("Invalid dependency version: {0}. The format is not recognizable.", dependencyKey),
dependencyValue,
projectPath);
}
SemanticVersionRange dependencyVersionRange = null;
if (!string.IsNullOrEmpty(dependencyVersionAsString?.Value))
{
try
{
dependencyVersionRange = VersionUtility.ParseVersionRange(dependencyVersionAsString.Value);
}
catch (Exception ex)
{
throw FileFormatException.Create(
ex,
dependencyValue,
projectPath);
}
}
results.Add(new LibraryDependency
{
LibraryRange = new LibraryRange(dependencyKey, isGacOrFrameworkReference)
{
VersionRange = dependencyVersionRange,
FileName = projectPath,
Line = dependencyValue.Line,
Column = dependencyValue.Column,
Target = target
},
Type = dependencyTypeValue
});
}
}
}
public void op_Add_string_JsonValue()
{
const string name = "name";
var expected = new JsonString("value");
var document = new JsonObject
{
{ name, expected }
};
var actual = document.String(name);
Assert.Equal(expected, actual);
}
public string ToJson()
{
return(JsonString.Convert(this));
}
static void TokensCommand(IEnumerable <string> args)
{
var help = Ref.Create(false);
var globDir = Ref.Create((DirectoryInfo)null);
var format = (string)null;
var options = new OptionSet(CreateStrictOptionSetArgumentParser())
{
Options.Help(help),
Options.Verbose(Verbose),
Options.Debug,
Options.Glob(globDir),
{ "f|format=", "where {FORMAT} is one of: json (default), csv, line", v => format = v.ToLowerInvariant() },
};
var tail = options.Parse(args);
if (help)
{
Help("tokens", options);
return;
}
var isMultiMode = tail.Count > 1;
switch (format)
{
case null:
case "json":
{
string indent = null;
if (isMultiMode)
{
Console.WriteLine("[");
indent = new string(' ', 4);
}
var i = 0;
foreach (var(path, source) in ReadSources(tail, globDir))
{
if (isMultiMode)
{
if (i > 0)
{
Console.WriteLine(",");
}
Console.WriteLine(" {");
Console.WriteLine(" \"file\": " + JsonString.Encode(path) + ",");
Console.WriteLine(" \"tokens\": [");
}
else
{
Console.WriteLine("[");
}
var tokens = Scanner.Scan(source);
var j = 0;
foreach (var token in tokens)
{
if (j > 0)
{
Console.WriteLine($",");
}
Console.WriteLine($"{indent} {{");
Console.WriteLine($"{indent} \"kind\": \"{token.Kind}\",");
Console.WriteLine($"{indent} \"span\": [[{token.Start.Offset}, {token.Start.Line}, {token.Start.Column}], [{token.End.Offset}, {token.End.Line}, {token.End.Column}]],");
Console.WriteLine($"{indent} \"text\": {JsonString.Encode(source, token.Start.Offset, token.Length)}");
Console.Write($"{indent} }}");
j++;
}
if (j > 0)
{
Console.WriteLine();
}
Console.WriteLine($"{indent}]");
if (isMultiMode)
{
Console.Write(" }");
i++;
}
}
if (isMultiMode)
{
Console.WriteLine();
Console.WriteLine("]");
}
break;
}
case "line":
{
foreach (var(path, source) in ReadSources(tail))
{
var lines =
from token in Scanner.Scan(source)
select new object[]
{
token.Kind,
$"{token.Start.Offset}/{token.Start.Line}:{token.Start.Column}...{token.End.Offset}/{token.End.Line}:{token.End.Column}",
JsonString.Encode(source, token.Start.Offset, token.Length),
}
into fs
select isMultiMode?fs.Append(JsonString.Encode(path)) : fs
into fs
select string.Join(" ", fs);
foreach (var line in lines)
{
Console.WriteLine(line);
}
}
break;
}
case "csv":
{
Console.WriteLine(
"token,text," +
"start_offset,end_offset," +
"start_line,start_column,end_line,end_column"
+ (isMultiMode ? ",file" : null));
foreach (var(path, source) in ReadSources(tail))
{
var rows =
from t in Scanner.Scan(source)
select new object[]
{
t.Kind,
Encode(t.Substring(source)),
t.Start.Offset.ToString(CultureInfo.InvariantCulture),
t.End.Offset.ToString(CultureInfo.InvariantCulture),
t.Start.Line.ToString(CultureInfo.InvariantCulture),
t.Start.Column.ToString(CultureInfo.InvariantCulture),
t.End.Line.ToString(CultureInfo.InvariantCulture),
t.End.Column.ToString(CultureInfo.InvariantCulture),
}
into fs
select isMultiMode?fs.Append(Encode(path)) : fs
into fs
select string.Join(",", fs);
foreach (var row in rows)
{
Console.WriteLine(row);
}
}
string Encode(string s)
{
const string quote = "\"";
const string quotequote = quote + quote;
var json = JsonString.Encode(s);
return(quote
+ json.Substring(1, json.Length - 2)
.Replace(quote, quotequote)
+ quote);
}
break;
}
}
}
/// 抓取早盘数据
/// <summary>
/// </summary>
public static void FootballMorningCrawler()
{
ILog loginfo = LogManager.GetLogger("logerror");
TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
var t = "0." + Convert.ToInt64(ts.TotalSeconds).ToString();
var footballMorningCrawler = new SimpleCrawler();//调用刚才写的爬虫程序
footballMorningCrawler.OnStart += (s, e) =>
{
Console.WriteLine("爬虫开始抓取地址：" + e.Uri.ToString());
};
footballMorningCrawler.OnError += (s, e) =>
{
var error = "爬虫抓取出现错误：" + e.Uri.ToString() + "，异常消息：" + e.Exception.Message + "，时间：" + DateTime.Now;
Console.WriteLine(error);
loginfo.Error(error);
};
footballMorningCrawler.OnCompleted += (s, e) =>
{
var url = e.Uri.AbsolutePath;
JavaScriptSerializer Serializer = new JavaScriptSerializer();
if (url.Contains("FBRresults"))
{
JsonString json = Serializer.Deserialize <JsonString>(e.PageSource);
DapperHelper.InsertEntity <FBRresults>(json.DB);
}
if (url.Contains("FootballMorning"))
{
JsonStringFootballMorning json = Serializer.Deserialize <JsonStringFootballMorning>(e.PageSource);
DapperHelper.InsertEntity <FootballMorning>(json.DB);
Match_Recommend(json.DB);
}
if (url.Contains("FootballToday"))
{
JsonStringFootballToday json = Serializer.Deserialize <JsonStringFootballToday>(e.PageSource);
DapperHelper.InsertEntity <FootballToday>(json.DB);
}
Console.WriteLine(e.PageSource);
Console.WriteLine("===============================================");
Console.WriteLine("耗时：" + e.Milliseconds + "毫秒");
Console.WriteLine("线程：" + e.ThreadId);
Console.WriteLine("地址：" + e.Uri.ToString());
loginfo.Error("===============================================");
loginfo.Error("执行成功，地址：" + e.Uri.ToString() + "时间：" + DateTime.Now);
};
List <PostUriData> postUriDataList = new List <PostUriData>();
for (var i = 1; i < 10; i++)
{
PostUriData postUriData = new PostUriData();
postUriData.Uri = new Uri("https://7345v.com/index.php/sports/Match/FootballMorning/?t=" + t);
postUriData.PostString = "&p=" + i + "&oddpk=H&leg=";
postUriDataList.Add(postUriData);
postUriData.PostString = "&p=" + i + "&oddpk=M&leg=";
postUriDataList.Add(postUriData);
postUriData.PostString = "&p=" + i + "&oddpk=I&leg=";
postUriDataList.Add(postUriData);
postUriData.PostString = "&p=" + i + "&oddpk=E&leg=";
postUriDataList.Add(postUriData);
PostUriData postUriData1 = new PostUriData();
postUriData1.Uri = new Uri("https://7345v.com/index.php/sports/Match/FootballToday/?t=" + t);
postUriData.PostString = "&p=" + i + "&oddpk=H&leg=";
postUriDataList.Add(postUriData);
postUriData.PostString = "&p=" + i + "&oddpk=M&leg=";
postUriDataList.Add(postUriData);
postUriData.PostString = "&p=" + i + "&oddpk=I&leg=";
postUriDataList.Add(postUriData);
postUriData.PostString = "&p=" + i + "&oddpk=E&leg=";
postUriDataList.Add(postUriData);
PostUriData postUriData2 = new PostUriData();
postUriData2.Uri = new Uri("https://7345v.com/index.php/sports/Match/FBRresults/?t=" + t);
postUriData2.PostString = "&time=" + i;
postUriDataList.Add(postUriData2);
}
Parallel.ForEach(postUriDataList, new ParallelOptions {
MaxDegreeOfParallelism = 3
}, (postUriData, pls, i) =>
{
footballMorningCrawler.StartPost(postUriData.Uri, postUriData.PostString); //Post请求
});
}
/// <summary>
/// Create JsonField with specifics name and value.
/// </summary>
/// <param name="name">Name of field.</param>
/// <param name="value">Value associated with this field.</param>
public JsonField(JsonString name, JsonValue value)
{
_name = name;
_value = value ?? JsonNull.value;
}
public void GlTFToJsonTest()
{
var gltf = new glTF();
using (var exporter = new gltfExporter(gltf))
{
exporter.Prepare(CreateSimpleScene());
exporter.Export();
}
var expected = gltf.ToJson().ParseAsJson();
expected.AddKey(Utf8String.From("meshes"));
expected.AddValue(default(ArraySegment <byte>), ValueNodeType.Array);
expected["meshes"].AddValue(default(ArraySegment <byte>), ValueNodeType.Object);
var mesh = expected["meshes"][0];
mesh.AddKey(Utf8String.From("name"));
mesh.AddValue(Utf8String.From(JsonString.Quote("test")).Bytes, ValueNodeType.String);
mesh.AddKey(Utf8String.From("primitives"));
mesh.AddValue(default(ArraySegment <byte>), ValueNodeType.Array);
mesh["primitives"].AddValue(default(ArraySegment <byte>), ValueNodeType.Object);
var primitive = mesh["primitives"][0];
primitive.AddKey(Utf8String.From("mode"));
primitive.AddValue(Utf8String.From("0").Bytes, ValueNodeType.Integer);
primitive.AddKey(Utf8String.From("indices"));
primitive.AddValue(Utf8String.From("0").Bytes, ValueNodeType.Integer);
primitive.AddKey(Utf8String.From("material"));
primitive.AddValue(Utf8String.From("0").Bytes, ValueNodeType.Integer);
primitive.AddKey(Utf8String.From("attributes"));
primitive.AddValue(default(ArraySegment <byte>), ValueNodeType.Object);
primitive["attributes"].AddKey(Utf8String.From("POSITION"));
primitive["attributes"].AddValue(Utf8String.From("0").Bytes, ValueNodeType.Integer);
primitive.AddKey(Utf8String.From("targets"));
primitive.AddValue(default(ArraySegment <byte>), ValueNodeType.Array);
primitive["targets"].AddValue(default(ArraySegment <byte>), ValueNodeType.Object);
primitive["targets"][0].AddKey(Utf8String.From("POSITION"));
primitive["targets"][0].AddValue(Utf8String.From("1").Bytes, ValueNodeType.Integer);
primitive["targets"].AddValue(default(ArraySegment <byte>), ValueNodeType.Object);
primitive["targets"][1].AddKey(Utf8String.From("POSITION"));
primitive["targets"][1].AddValue(Utf8String.From("2").Bytes, ValueNodeType.Integer);
primitive["targets"][1].AddKey(Utf8String.From("TANGENT"));
primitive["targets"][1].AddValue(Utf8String.From("0").Bytes, ValueNodeType.Integer);
gltf.meshes.Add(new glTFMesh("test")
{
primitives = new List <glTFPrimitives>
{
new glTFPrimitives
{
indices = 0,
attributes = new glTFAttributes
{
POSITION = 0,
TANGENT = -1 // should be removed
},
targets = new List <gltfMorphTarget>
{
new gltfMorphTarget
{
POSITION = 1,
TANGENT = -1 // should be removed
},
new gltfMorphTarget
{
POSITION = 2,
TANGENT = 0
}
}
}
}
});
var actual = gltf.ToJson().ParseAsJson();
Assert.AreEqual(expected, actual);
}
public static void TestDefaultCtor()
{
var jsonString = new JsonString();
Assert.Equal("", jsonString.Value);
}
public static string Jsonify(this string json)
{
return(JsonString.jsonify(json));
}
public StatementValidator()
{
Include(new StatementBaseValidator());
RuleFor(x => x.Object as SubStatement)
.SetValidator(new SubStatementValidator())
.When(x => x.Object != null && x.Object.ObjectType == ObjectType.SubStatement);
// TODO: https://github.com/adlnet/xAPI-Spec/blob/master/xAPI-Data.md#requirements-14
RuleFor(x => x.Authority).SetValidator(new AgentValidator())
.When(x => x.Authority != null && x.Authority.ObjectType == ObjectType.Agent);
RuleFor(x => x.Authority)
.Must(auth =>
{
var grp = auth as Group;
return(grp.Member.Count == 2 && auth.IsAnonymous());
})
.When(x => x.Authority != null && x.Authority.ObjectType == ObjectType.Group)
.WithMessage("When 3-legged OAuth, the anonymous group must have 2 Agents. The two Agents represent an application and user together.");
RuleFor(x => x.Object.ObjectType)
.Equal(ObjectType.StatementRef)
.When(x => x.Verb?.Id == KnownVerbs.Voided)
.WithMessage("When statement verb is voided, statement object must be StatementRef.");
RuleFor(x => x).Custom((statement, context) =>
{
var attachments = statement.Attachments;
for (int i = 0; i < attachments.Count; i++)
{
var attachment = attachments.ElementAt(i);
if (attachment.UsageType == new Iri("http://adlnet.gov/expapi/attachments/signature"))
{
if (attachment.ContentType != "application/octet-stream")
{
context.AddFailure($"Attachments[{i}].ContentType", "Must be \"application/octet-stream\"");
continue;
}
var jws = JsonWebSignature.Parse(Encoding.UTF8.GetString(attachment.Payload));
if (jws.Errors.Count() > 0)
{
string key = $"Attachment[{i}].Payload";
// context.AddFailure(key, "Invalid JWS Signature.");
foreach (var error in jws.Errors)
{
context.AddFailure(key, error.Message);
}
continue;
}
string alg = jws.ProtectedHeader.Value <string>("alg");
if (!new string[] { "RS256", "RS384", "RS512" }.Contains(alg))
{
context.AddFailure($"Attachments[{i}].Pyload", "The JWS signature MUST use an algorithm of \"RS256\", \"RS384\", or \"RS512\".");
}
var jsonString = new JsonString(jws.Payload);
if (!jsonString.IsValid())
{
context.AddFailure($"Attachments[{i}].Pyload", "JWS Payload is not valid json format.");
continue;
}
var payloadStatement = new Statement(jsonString);
if (!payloadStatement.Equals(statement))
{
context.AddFailure($"Attachments[{i}].Pyload", "JWS Payload does not match the signed statement.");
}
}
}
});
}
//static byte[] socBuffer = new byte[64];
//static char[] cbuffer = new char[128];
//static int capacity = 256;
//static int defaultSize = 500;
//static bool isPub = false;
//static bool isString = true;
//static int testCount = 1000000;
//static bool toString = true;
//static bool isInfo = false;
//static bool isConsole = false;
//static SerializerSettings sets = new SerializerSettings();
#endregion
public static TestResult Test(object graph)
{
TestResult result = new TestResult();
while (true)
{
#region 参数
int len = testCount;
JsonStringContext info = ShiboSerializer.GetJsonStringTypeInfos(graph.GetType());
JsonSerializerSettings nset = new JsonSerializerSettings();
//nset.StringEscapeHandling = StringEscapeHandling.EscapeNonAscii;
BinaryFormatter binserializer = new BinaryFormatter();
//var serializer = MessagePackSerializer.Create(graph.GetType());
MemoryStream msBin = new MemoryStream();
MemoryStream socStream = new MemoryStream();
MemoryStream msgStream = new MemoryStream();
MemoryStream protopufStream = new MemoryStream();
#endregion
#region 启动
int size = 0;
string s = string.Empty;
ObjectStreamWriter socOStream = new ObjectStreamWriter(socStream);
//ShiboSerializer.BinSerialize(os, graph, sets);
//ShiboSerializer.Serialize(graph);
//ShiboSerializer.BinSerialize(graph);
if (TestBaseConfig.Fastest)
{
Console.WriteLine(ShiboSerializer.Serialize(graph));
}
if (TestBaseConfig.Soc)
{
ShiboSerializer.BinarySerialize(graph);
}
//if (TestBaseConfig.MsgPack)
// serializer.PackSingleObject(graph);
if (TestBaseConfig.SocStream)
{
ShiboSerializer.BinarySerialize(socOStream, graph);
}
if (TestBaseConfig.Newtonsoft)
{
JsonConvert.SerializeObject(graph);
}
if (TestBaseConfig.BinaryFormatter)
{
binserializer.Serialize(msBin, graph);
}
if (TestBaseConfig.ServiceStack)
{
ServiceStack.Text.JsonSerializer.SerializeToString(graph);
}
//if (TestBaseConfig.JavaScriptSerializer)
// serializer.Serialize(graph);
//if (TestBaseConfig.DataContractJsonSerializer)
// JsonSerializer(ser, graph);
#endregion
#region 测试
Stopwatch w = System.Diagnostics.Stopwatch.StartNew();
if (TestBaseConfig.Soc)
{
w.Restart();
for (int i = 0; i < len; i++)
{
//byte[] bytes = ShiboSerializer.BinSerialize(graph);
//size += bytes.Length;
ObjectWriter stream = new ObjectWriter(socBuffer);
ShiboSerializer.BinarySerialize(stream, graph);
size += stream.Position;
}
w.Stop();
Console.WriteLine();
Console.WriteLine("Time Soc Serializer= " + w.ElapsedMilliseconds + " v:" + size);
}
if (TestBaseConfig.MsgPack)
{
size = 0;
w.Restart();
//for (int i = 0; i < len; i++)
//{
// byte[] bytes = serializer.PackSingleObject(graph);
// size += bytes.Length;
//}
w.Stop();
Console.WriteLine();
Console.WriteLine("Time MsgPack Serializer= " + w.ElapsedMilliseconds + " v:" + size);
}
if (TestBaseConfig.ProtoBuf)
{
size = 0;
w.Restart();
for (int i = 0; i < len; i++)
{
//protopufStream.Position = 0;
protopufStream = new MemoryStream(100);
Serializer.Serialize(protopufStream, graph);
size += (int)protopufStream.Length;
}
w.Stop();
Console.WriteLine();
Console.WriteLine("Time ProtoBuf Serializer= " + w.ElapsedMilliseconds + " v:" + size);
}
if (TestBaseConfig.Fastest)
{
size = 0;
w.Restart();
for (int i = 0; i < len; i++)
{
JsonString stream = new JsonString(jsonBuffer);
ShiboSerializer.Serialize(stream, graph);
size += stream.Position;
}
w.Stop();
Console.WriteLine();
Console.WriteLine("Time Fastest Serializer= " + w.ElapsedMilliseconds + " v:" + size);
}
if (TestBaseConfig.Newtonsoft)
{
size = 0;
w.Restart();
for (int i = 0; i < len; i++)
{
string json = JsonConvert.SerializeObject(graph);
size += json.Length;
}
w.Stop();
Console.WriteLine();
Console.WriteLine("Time Newtonsoft Serializer= " + w.ElapsedMilliseconds + " v:" + size);
}
if (TestBaseConfig.ServiceStack)
{
size = 0;
w.Restart();
for (int i = 0; i < len; i++)
{
string json = ServiceStack.Text.JsonSerializer.SerializeToString(graph);
size += json.Length;
}
w.Stop();
Console.WriteLine();
Console.WriteLine("Time ServiceStack Serializer= " + w.ElapsedMilliseconds + " v:" + size);
}
if (TestBaseConfig.BinaryFormatter)
{
size = 0;
w.Restart();
for (int i = 0; i < len; i++)
{
MemoryStream stream = new MemoryStream();
binserializer.Serialize(stream, graph);
size += (int)stream.Length;
}
w.Stop();
Console.WriteLine();
Console.WriteLine("Time BinaryFormatter Serializer= " + w.ElapsedMilliseconds + " v:" + size);
}
#endregion
break;
}
return(result);
}
public static void JsonTest(object graph)
{
while (true)
{
int len = testCount;
JsonStringContext info = ShiboSerializer.GetJsonStringTypeInfos(graph.GetType());
JsonSerializerSettings nset = new JsonSerializerSettings();
//nset.StringEscapeHandling = StringEscapeHandling.EscapeNonAscii;
DataContractJsonSerializer ser = new DataContractJsonSerializer(graph.GetType());
BinaryFormatter binserializer = new BinaryFormatter();
MemoryStream msBin = new MemoryStream();
binserializer.Serialize(msBin, graph);
//JavaScriptSerializer serializer = new JavaScriptSerializer();
int v = 0;
string s = string.Empty;
if (isString)
{
JsonString os = new JsonString(buffer);
if (isInfo)
{
ShiboSerializer.Serialize(os, graph, info, sets);
}
else
{
ShiboSerializer.Serialize(os, graph, sets);
}
s = os.ToString();
}
else
{
//JsonStream os = new JsonStream();
//ShiboSerializer.Serialize(os, graph, sets);
//s = os.ToString();
}
//fastJSON.JSONParameters fp = new fastJSON.JSONParameters() { UsingGlobalTypes = false, UseExtensions = false };
MemoryStream msPub = new MemoryStream();
if (isConsole)
{
Console.WriteLine(s);
Console.WriteLine();
Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(graph, nset));
Console.WriteLine();
if (isPub == true)
{
Serializer.Serialize(msPub, graph);
Console.WriteLine("PB:" + msPub.Length.ToString());
Console.WriteLine();
}
Console.WriteLine(ServiceStack.Text.JsonSerializer.SerializeToString(graph));
Console.WriteLine();
//Console.WriteLine(fastJSON.JSON.Instance.ToJSON(graph, fp));
//Console.WriteLine();
//Console.WriteLine(serializer.Serialize(graph));
Console.WriteLine();
Console.WriteLine(JsonSerializer(ser, graph));
Console.WriteLine();
}
else
{
Newtonsoft.Json.JsonConvert.SerializeObject(graph, nset);
if (isPub == true)
{
Serializer.Serialize(msPub, graph);
}
ServiceStack.Text.JsonSerializer.SerializeToString(graph);
//fastJSON.JSON.Instance.ToJSON(graph, fp);
//serializer.Serialize(graph);
JsonSerializer(ser, graph);
}
Console.WriteLine();
if (s != Newtonsoft.Json.JsonConvert.SerializeObject(graph, nset))
{
Console.WriteLine("may error --Json.Net ");
}
else
{
Console.WriteLine("ok --Json.Net");
}
Console.WriteLine();
if (s != ServiceStack.Text.JsonSerializer.SerializeToString(graph))
{
Console.WriteLine("may error ----ServiceStack.Text");
}
else
{
Console.WriteLine("ok --ServiceStack.Text");
}
//Console.WriteLine();
//if (s != fastJSON.JSON.Instance.ToJSON(graph, fp))
// Console.WriteLine("结果不一样，有错误！ ----fastJSON");
//else
// Console.WriteLine("和 fastJSON 正确");
//if (s.Length != fastJSON.JSON.Instance.ToJSON(graph, fp).Length)
// Console.WriteLine("长度不一样，有错误！ ----fastJSON");
//else
// Console.WriteLine("和 fastJSON 长度正确");
Stopwatch w = Stopwatch.StartNew();
w.Start();
w = System.Diagnostics.Stopwatch.StartNew();
w.Start();
if (isString)
{
if (isInfo)
{
for (int i = 0; i < len; i++)
{
JsonString os = new JsonString(buffer);
ShiboSerializer.Serialize(os, graph, info, sets);
if (toString == false)
{
v += os.Position;
}
else
{
v += os.ToString().Length;
}
}
}
else
{
for (int i = 0; i < len; i++)
{
JsonString os = new JsonString(buffer);
ShiboSerializer.Serialize(os, graph, sets);
if (toString == false)
{
v += os.Position;
}
else
{
v += os.ToString().Length;
}
}
}
}
else
{
for (int i = 0; i < len; i++)
{
//JsonStream os = new JsonStream(capacity);
//ShiboSerializer.Serialize(os, graph, sets);
//if (toString == false)
// v += os.Position;
//else
// v += os.ToString().Length;
}
}
w.Stop();
Console.WriteLine();
Console.WriteLine("Time Fastest.Json serializer= " + w.ElapsedMilliseconds + " v:" + v);
v = 0;
w.Restart();
for (int i = 0; i < len; i++)
{
string st = Newtonsoft.Json.JsonConvert.SerializeObject(graph, nset);
v += st.Length;
}
w.Stop();
Console.WriteLine();
Console.WriteLine("Time JsonConvert serializer= " + w.ElapsedMilliseconds + " v:" + v);
if (isPub)
{
v = 0;
w.Restart();
for (int i = 0; i < len; i++)
{
msPub = new MemoryStream();
Serializer.Serialize(msPub, graph);
v += (int)msPub.Length;
}
w.Stop();
Console.WriteLine();
Console.WriteLine("Time Protocol Buffer serializer= " + w.ElapsedMilliseconds + " v:" + v);
}
v = 0;
w.Restart();
for (int i = 0; i < len; i++)
{
string st = ServiceStack.Text.JsonSerializer.SerializeToString(graph);
v += st.Length;
}
w.Stop();
Console.WriteLine();
Console.WriteLine("Time ServiceStack serializer= " + w.ElapsedMilliseconds + " v:" + v);
v = 0;
w.Restart();
for (int i = 0; i < len; i++)
{
//StringBuilder sb = new StringBuilder(120);
//sb.Append('[');
//string[] strs = (string[])graph;
//for (int n = 0; n < strs.Length; n++)
//{
// sb.Append('"');
// if (strs[n] == null)
// sb.Append("null");
// else if (strs[n].Length == 0)
// sb.Append("\"\"");
// else
// sb.Append(strs[n]);
// sb.Append('"');
// sb.Append(',');
//}
//sb.Length--;
//sb.Append(']');
//v += sb.ToString().Length;
v += graph.ToString().Length;
}
w.Stop();
Console.WriteLine();
Console.WriteLine("Time StringBuilder serializer= " + w.ElapsedMilliseconds + " v:" + v);
v = 0;
w.Restart();
for (int i = 0; i < len; i++)
{
MemoryStream stream = new MemoryStream();
binserializer.Serialize(stream, graph);
v += (int)stream.Length;
}
w.Stop();
Console.WriteLine();
Console.WriteLine("Time BinaryFormatter serializer= " + w.ElapsedMilliseconds + " v:" + v);
//v = 0;
//w.Restart();
//for (int i = 0; i < len; i++)
//{
// string st = serializer.Serialize(graph);
// v += st.Length;
//}
//w.Stop();
//Console.WriteLine();
//Console.WriteLine("Time JavaScriptSerializer serializer= " + w.ElapsedMilliseconds + " v:" + v);
v = 0;
w.Restart();
for (int i = 0; i < len; i++)
{
string st = JsonSerializer(ser, graph);
v += st.Length;
}
w.Stop();
Console.WriteLine();
Console.WriteLine("Time DataContractJsonSerializer serializer= " + w.ElapsedMilliseconds + " v:" + v);
break;
}
}
public override HttpStatusCode Respond(JsonString subject, JsonString response)
{
if (subject == null)
{
throw new ArgumentNullException("subject");
}
if (response == null)
{
throw new ArgumentNullException("response");
}
// read properties from the request
string topic = JsonString.ParseString(subject.GetTerminal("topic", string.Empty), string.Empty);
if (!topic.Equals("sensorCapture"))
{
return(HttpStatusCode.BadRequest);
}
int positionStart, positionEnd;
if (!ReadPosition(subject, out positionStart, out positionEnd))
{
return(HttpStatusCode.BadRequest);
}
if (positionStart != positionEnd)
{
// not supported
return(HttpStatusCode.BadRequest);
}
var template = new JsonString(response);
template.RemoveTerminal("requestId");
var responseSubject = JsonString.CreateDict();
{
responseSubject.AddTerminal("type", "\"post\"");
responseSubject.AddTerminal("topic", "\"sensorCapture\"");
responseSubject.AddTerminal("position", JsonString.Stringify(positionStart));
responseSubject.AddJsonString("data", JsonString.CreateArray());
}
response.AddJsonString("subject", responseSubject);
// the client can request optional information
// captured images can take a lot of bandwidth and are there off by default
int timeout = 10000;
bool includeImage = false;
var dataArray = subject.GetJsonString("data");
if (dataArray != null)
{
var data = dataArray.GetJsonString(0);
if (data != null)
{
timeout = JsonString.ParseInt(data.GetTerminal("timeout", ""), (int)timeout);
includeImage = JsonString.ParseBool(data.GetTerminal("includeImage", "false"), false);
}
}
// try to get sensor data
// here we create an observer-relay pair that relays captured data to explicitly requesting clients
// a request will be active for a couple of seconds, then the client has to resend it
// the sensor observer generates data when the webcam is active
// which is send to the client through LiveWire subscription (relay)
// TODO advance this functionality
// TODO distinguish between different types of requests (start/stop/only for live stats e.g. fps/+image data)
// TODO need a lock here too?
int iSensor = positionStart;
var readySignal = new AutoResetEvent(false);
object sync = new object();
ulong relayID = LiveCaptureSubscription.GenerateSubscriptionID(clientOrigin, SensorType.Webcam, iSensor);
LiveCaptureSubscription relay = new LiveCaptureSubscription(relayID);
HttpStatusCode status = HttpStatusCode.InternalServerError;
CaptureSystem.Instance.Invoke((object sender, EventArgs args) => {
var system = (CaptureSystem)sender;
// make sure the sensor is started
// and subscribe to it if successful
ISensorBase sensor = system.GetSensor(iSensor);
if (sensor == null || sensor.SensorType != SensorType.Webcam)
{
lock (sync) {
status = HttpStatusCode.NotFound;
}
readySignal.Set();
return;
}
lock (sync) {
// when the observer times out its subscription to camera events should end
// in order to save resources
// the observer cancels the relay in the process
var observer = new WebcamCaptureObserver(timeout, includeImage, clientOrigin, relay, iSensor, template);
IDisposable subscription = system.ObserveSensor(positionStart).Subscribe(observer);
observer.Cancelled += delegate {
subscription.Dispose();
};
LogManager.Instance.LogMessage(this, string.Format("Subscribed client {0} to webcam {1} as {2}",
clientOrigin, iSensor, relayID));
status = HttpStatusCode.OK;
}
readySignal.Set();
});
// cancellation makes sure that a client is only fed by one observer-relay pair at a time
// search for conflicting subscriptions and cancel them
// conflicts have the same ID as generated above
var activeConsumers = server.GetSubscriptions(clientOrigin);
foreach (var c in activeConsumers)
{
if (c.SubscriptionID == relayID)
{
c.Cancel();
LogManager.Instance.LogMessage(this, string.Format("Replaced webcam video subscription {0} for client {1}",
relayID, clientOrigin));
}
}
// wait for the external operation above to finish
// starting a webcam can take a few seconds
if (!readySignal.WaitOne(10000))
{
relay.Dispose();
return(HttpStatusCode.InternalServerError);
}
// since we have no synchronization other than on readySignal we make use of an additional lock
// otherwise the ready signal could be set, while we see an old status code value
// TODO check validity of statement above
lock (sync) {
if (status != HttpStatusCode.OK)
{
relay.Dispose();
return(status);
}
if (!server.Subscribe(clientOrigin, relay))
{
relay.Dispose();
return(HttpStatusCode.InternalServerError);
}
return(HttpStatusCode.OK);
}
// TODO create an update in case the sensor was started
}
private static void serialize(JsonResult result, int count)
{
string s = "";
JsonStringContext info = ShiboSerializer.GetJsonStringTypeInfos(result.GetType());
Console.WriteLine("序列化开始({0}),单位毫秒", count);
System.Diagnostics.Stopwatch w = new System.Diagnostics.Stopwatch();
Console.WriteLine("Fastest.Json");
for (int i = 0; i < 5; i++)
{
w.Start();
for (int j = 0; j < count; j++)
{
JsonString stream = new JsonString(defaultSize);
if (isInfo)
{
ShiboSerializer.Serialize(stream, result, info, sets);
}
else
{
ShiboSerializer.Serialize(stream, result, sets);
}
s = stream.ToString();
}
w.Stop();
Console.Write("{0} ", (w.ElapsedMilliseconds / (count * 1.0)).ToString());
w.Reset();
}
Console.WriteLine(s);
Console.WriteLine("\r\nServiceStack.Text");
for (int i = 0; i < 5; i++)
{
w.Start();
for (int j = 0; j < count; j++)
{
s = ServiceStack.Text.JsonSerializer.SerializeToString <JsonResult>(result);
}
w.Stop();
Console.Write("{0} ", (w.ElapsedMilliseconds / (count * 1.0)).ToString());
w.Reset();
}
Console.WriteLine(s);
Console.WriteLine("\r\nNewtonsoft.Json");
for (int i = 0; i < 5; i++)
{
w.Start();
for (int j = 0; j < count; j++)
{
s = Newtonsoft.Json.JsonConvert.SerializeObject(result);
}
w.Stop();
Console.Write("{0} ", (w.ElapsedMilliseconds / (count * 1.0)).ToString());
w.Reset();
}
Console.WriteLine(s);
//Console.WriteLine("\r\nJavaScriptSerializer");
//JavaScriptSerializer serializer = new JavaScriptSerializer();
//for (int i = 0; i < 5; i++)
//{
// w.Start();
// for (int j = 0; j < count; j++)
// {
// s = serializer.Serialize(result);
// }
// w.Stop();
// Console.Write("{0} ", (w.ElapsedMilliseconds / (count * 1.0)).ToString());
// w.Reset();
//}
//Console.WriteLine(s);
Console.WriteLine("\r\nDataContractJsonSerializer");
for (int i = 0; i < 5; i++)
{
w.Start();
for (int j = 0; j < count; j++)
{
s = JsonSerializer(result);
}
w.Stop();
Console.Write("{0} ", (w.ElapsedMilliseconds / (count * 1.0)).ToString());
w.Reset();
}
Console.WriteLine(s);
}
static private object[] _GetBuildXmlHelper(Lua state, JsonString passivesJson, JsonString itemsJson)
{
using (var func = state.GetFunction("getBuildXmlByJsons"))
{
return(func.Call(passivesJson.Value, itemsJson.Value));
}
}
public JsonObject ToJson()
{
// {"N":"225"}
// {"S":"Hello"}
// {"SS": ["Keneau", "Alexis", "John"]}
// {"NS": ["1", "2", "3"]}
JsonNode node;
if (kind == DbValueType.M)
{
node = ((AttributeCollection)value).ToJson();
}
else if (kind == DbValueType.B && value is byte[] data)
{
node = new JsonString(Convert.ToBase64String(data));
}
else if (kind == DbValueType.L)
{
var list = new XNodeArray();
foreach (var item in (IEnumerable <DbValue>)value)
{
list.Add(item.ToJson());
}
node = list;
}
else if (value.GetType().IsArray)
{
var elementType = value.GetType().GetElementType();
if (elementType == typeof(string))
{
node = new XImmutableArray <string>((string[])value);
}
else
{
var list = new List <string>();
foreach (var item in (IEnumerable)value)
{
list.Add(item.ToString());
}
node = new XList <string>(list);
}
}
else if (kind == DbValueType.BOOL)
{
var val = (bool)value;
node = val ? JsonBoolean.True : JsonBoolean.False;
}
else
{
node = new JsonString(value.ToString());
}
return(new JsonObject {
{ kind.ToQuickString(), node }
});
}
public Verb(JsonString jsonString) : this(jsonString.ToJToken())
{
}
private void UpdateDataSource(bool isSync)
{
_eventAggregator.GetEvent <SyncDataSourceEvent>().Publish(isSync ? JsonString?.Trim() : null);
}
private static void PopulateDependencies(
string projectPath,
IList <LibraryRange> results,
JsonObject settings,
string propertyName,
bool isGacOrFrameworkReference)
{
var dependencies = settings.ValueAsJsonObject(propertyName);
if (dependencies != null)
{
foreach (var dependencyKey in dependencies.Keys)
{
if (string.IsNullOrEmpty(dependencyKey))
{
throw FileFormatException.Create(
"Unable to resolve dependency ''.",
dependencies.Value(dependencyKey),
projectPath);
}
var dependencyValue = dependencies.Value(dependencyKey);
var dependencyTypeValue = LibraryDependencyType.Default;
JsonString dependencyVersionAsString = null;
LibraryType target = isGacOrFrameworkReference ? LibraryType.ReferenceAssembly : LibraryType.Unspecified;
if (dependencyValue is JsonObject)
{
// "dependencies" : { "Name" : { "version": "1.0", "type": "build", "target": "project" } }
var dependencyValueAsObject = (JsonObject)dependencyValue;
dependencyVersionAsString = dependencyValueAsObject.ValueAsString("version");
var type = dependencyValueAsObject.ValueAsString("type");
if (type != null)
{
dependencyTypeValue = LibraryDependencyType.Parse(type.Value);
}
// Read the target if specified
if (!isGacOrFrameworkReference)
{
LibraryType parsedTarget;
var targetStr = dependencyValueAsObject.ValueAsString("target");
if (!string.IsNullOrEmpty(targetStr) && LibraryType.TryParse(targetStr, out parsedTarget))
{
target = parsedTarget;
}
}
}
else if (dependencyValue is JsonString)
{
// "dependencies" : { "Name" : "1.0" }
dependencyVersionAsString = (JsonString)dependencyValue;
}
else
{
throw FileFormatException.Create(
string.Format("Invalid dependency version: {0}. The format is not recognizable.", dependencyKey),
dependencyValue,
projectPath);
}
VersionRange dependencyVersionRange = null;
if (!string.IsNullOrEmpty(dependencyVersionAsString?.Value))
{
try
{
dependencyVersionRange = VersionRange.Parse(dependencyVersionAsString.Value);
}
catch (Exception ex)
{
throw FileFormatException.Create(
ex,
dependencyValue,
projectPath);
}
}
results.Add(new LibraryRange(
dependencyKey,
dependencyVersionRange,
target,
dependencyTypeValue,
projectPath,
dependencies.Value(dependencyKey).Line,
dependencies.Value(dependencyKey).Column));
}
}
}
public JsonString ReturnClassAsJsonString(string name)
{
return(JsonString.FromObject(new JsSerializableClass {
Value = name
}));
}
public int JsonIndexOf(String str)
{
return(JsonString.IndexOf(str));
}
public void then_slash_symbol_translated_correctly()
{
JsonString.Should().Be(AddRootField("{\"slash\":\"\\\\value\"}"));
}
public void then_quote_symbol_translated_correctly()
{
JsonString.Should().Be(AddRootField("{\"quote\":\"\\\"value\"}"));
}
/// <summary>
/// Execute a method call over the DevTools protocol. This is a more structured
/// version of SendDevToolsMessage.
/// See the DevTools protocol documentation at https://chromedevtools.github.io/devtools-protocol/ for details
/// of supported methods and the expected <paramref name="paramsAsJson"/> dictionary contents.
/// See the SendDevToolsMessage documentation for additional usage information.
/// </summary>
/// <param name="messageId">is an incremental number that uniquely identifies the message (pass 0 to have the next number assigned
/// automatically based on previous values)</param>
/// <param name="method">is the method name</param>
/// <param name="parameters">are the method parameters represented as a <see cref="JsonString"/>,
/// which may be empty.</param>
/// <returns>return the assigned message Id if called on the CEF UI thread and the message was
/// successfully submitted for validation, otherwise 0</returns>
public static int ExecuteDevToolsMethod(this IBrowserHost browserHost, int messageId, string method, JsonString parameters)
{
WebBrowserExtensions.ThrowExceptionIfBrowserHostNull(browserHost);
var json = parameters == null ? null : parameters.Json;
return(browserHost.ExecuteDevToolsMethod(messageId, method, json));
}
private ActivityDefinition GetActivityInteraction(int interactionIndex)
{
ActivityDefinition interactionDef = null;
using (SqlConnection connection = new SqlConnection(DbUtils.GetConnectionString()))
{
SqlDataReader reader = null;
SqlCommand command = new SqlCommand(GetActivityInteractionQuery, connection);
command.Parameters.AddWithValue("@id", interactionIndex);
try
{
connection.Open();
reader = command.ExecuteReader();
if (reader.Read())
{
InteractionType type = reader.GetString(1);
interactionDef = type.CreateInstance(new JObject(), ApiVersion.GetLatest());
if (!reader.IsDBNull(2))
{
JsonString json = reader.GetString(2);
var sList = new List <string>();
var crp = json.ToJArray();
foreach (var jstring in crp)
{
sList.Add(jstring.Value <string>());
}
(interactionDef as InteractionActivityDefinitionBase).CorrectResponsesPattern = sList.ToArray();
}
if (!reader.IsDBNull(3))
{
Choice cho = interactionDef as Choice;
Sequencing seq = interactionDef as Sequencing;
if (cho != null)
{
cho.Choices = new InteractionComponentCollection(reader.GetString(3));
}
else if (seq != null)
{
seq.Choices = new InteractionComponentCollection(reader.GetString(3));
}
}
if (!reader.IsDBNull(4))
{
Likert def = interactionDef as Likert;
if (def != null)
{
def.Scale = new InteractionComponentCollection(reader.GetString(4));
}
}
if (!reader.IsDBNull(5))
{
Matching match = interactionDef as Matching;
if (match != null)
{
match.Source = new InteractionComponentCollection(reader.GetString(5));
}
}
if (!reader.IsDBNull(6))
{
Matching match = interactionDef as Matching;
if (match != null)
{
match.Target = new InteractionComponentCollection(reader.GetString(6));
}
}
if (!reader.IsDBNull(7))
{
Performance perf = interactionDef as Performance;
if (perf != null)
{
perf.Steps = new InteractionComponentCollection(reader.GetString(7));
}
}
}
}
catch (Exception ex)
{
return(null);
}
finally
{
if (reader != null && !reader.IsClosed)
{
reader.Close();
}
}
}
return(interactionDef);
}
private static string Translate(string input, ref Language sourceLanguage, Language targetLanguage)
{
string results = "";
if ((input == null) || (input == ""))
{
return("");
}
string NewLine = "!!!!";
input = input.Replace(Environment.NewLine, NewLine);
// phrase= phrase.Replace(Environment.NewLine, "<br>");
string url = string.Format(LanguageTranslatePostString, LanguageApiVersion,
HttpUtility.UrlEncode(input, Encoding.UTF8),
LanguageHelper.GetLanguageString(sourceLanguage),
LanguageHelper.GetLanguageString(targetLanguage));
//string responseData = CoreHelper.PerformRequest(url);
string responseData = CoreHelper.BuildWebRequest(LanguageTranslateUrl, url);
JsonObject jsonObject = CoreHelper.ParseGoogleAjaxAPIResponse(responseData);
// Translation response validation
// Get 'responseData'
if (jsonObject.ContainsKey("responseData") == false)
{
throw new GapiException("Invalid response - no responseData: " + responseData);
}
if (!(jsonObject["responseData"] is JsonObject))
{
throw new GapiException("Invalid response - responseData is not JsonObject: " + responseData);
}
// Get 'translatedText'
JsonObject responseContent = (JsonObject)jsonObject["responseData"];
if (responseContent.ContainsKey("translatedText") == false)
{
throw new GapiException("Invalid response - no translatedText: " + responseData);
}
if (!(responseContent["translatedText"] is JsonString))
{
throw new GapiException("Invalid response - translatedText is not JsonString: " + responseData);
}
string translatedPhrase = ((JsonString)responseContent["translatedText"]).Value;
// If there's a detected language - return it
if ((responseContent.ContainsKey("detectedSourceLanguage") == true) &&
(responseContent["detectedSourceLanguage"] is JsonString))
{
JsonString detectedSourceLanguage = (JsonString)responseContent["detectedSourceLanguage"];
sourceLanguage = LanguageHelper.GetLanguage(detectedSourceLanguage.Value);
}
results += HttpUtility.HtmlDecode(translatedPhrase) + Environment.NewLine;
results = results.Replace(NewLine, Environment.NewLine);
return(results);
}
public Task <JsonString> PostFromQueryImplicit(string str, CancellationToken cancellationToken)
{
var jsonString = new JsonString(str);
return(Task.FromResult(jsonString));
}
public Task <JsonString> PostWithBody([FromBody] StringWrapper wrapper, CancellationToken cancellationToken)
{
var jsonString = new JsonString(wrapper.Body);
return(Task.FromResult(jsonString));
}
public Context(JsonString jsonString) : this(jsonString.ToJToken(), ApiVersion.GetLatest())
{
}
public void op_String_string()
{
const string name = "name";
var expected = new JsonString("value");
var document = new JsonObject
{
new JsonPair(name, expected)
};
var actual = document.String(name);
Assert.Equal(expected, actual);
}
public void op_String_int()
{
var expected = new JsonString("value");
var document = new JsonArray
{
Values =
{
expected
}
};
var actual = document.String(0);
Assert.Equal(expected, actual);
}
