public void NewEntryGetsGuid() { Extensible extensibleInfo = new Extensible(); extensibleInfo.Guid = Guid.NewGuid(); LexEntry e = _builder.GetOrMakeEntry(extensibleInfo, 0); Assert.AreEqual(extensibleInfo.Guid, e.Guid); _builder.FinishEntry(e); Assert.AreEqual(1, _repository.CountAllItems()); }
public ActivityDefinition(LanguageMap name,LanguageMap description, Uri type, string interactionType, string moreInfo, Extensible extensions) { this.name = name; this.description = description; this.type = type; this.interaction = interaction; this.moreInfo = moreInfo; this.extensions = extensions; }
public void NewEntry_NoDefYesGloss_GlossCopiedToDefintion() { Extensible extensibleInfo = new Extensible(); LexEntry e = _builder.GetOrMakeEntry(extensibleInfo, 0); LexSense s = _builder.GetOrMakeSense(e, new Extensible(), string.Empty); _builder.MergeInGloss(s, new LiftMultiText("x","x meaning")); _builder.FinishEntry(e); Assert.AreEqual("x meaning",e.Senses[0].Gloss.GetExactAlternative("x")); Assert.AreEqual("x meaning",e.Senses[0].Definition.GetExactAlternative("x")); }
public void NewEntryGetsDates() { Extensible extensibleInfo = new Extensible(); extensibleInfo.CreationTime = DateTime.Parse("2/2/1969 12:15:12").ToUniversalTime(); extensibleInfo.ModificationTime = DateTime.Parse("10/11/1968 12:15:12").ToUniversalTime(); LexEntry e = _builder.GetOrMakeEntry(extensibleInfo, 0); Assert.AreEqual(extensibleInfo.CreationTime, e.CreationTime); Assert.AreEqual(extensibleInfo.ModificationTime, e.ModificationTime); _builder.FinishEntry(e); Assert.AreEqual(1, _repository.CountAllItems()); }
public void Construct_ModificationTimeIsUtc() { Extensible e = new Extensible(); Assert.AreEqual(DateTimeKind.Utc, e.ModificationTime.Kind); }
public void EntryWithChildren() { Extensible extensibleInfo = new Extensible(); LexEntry e = MakeSimpleEntry(); LexSense s = _builder.GetOrMakeSense(e, extensibleInfo, string.Empty); LexExampleSentence ex = _builder.GetOrMakeExample(s, new Extensible()); ex.Sentence["foo"] = "this is a sentence"; ex.Translation["aa"] = "aaaa"; _builder.FinishEntry(e); CheckCompleteEntry(e); RepositoryId[] entries = _repository.GetAllItems(); Assert.AreEqual(1, entries.Length); //now check it again, from the list CheckCompleteEntry(_repository.GetItem(entries[0])); }
private static object FastNew(CodeContext /*!*/ context, object o) { Extensible <BigInteger> el; if (o is string) { return(__new__(null, (string)o, 10)); } if (o is double) { return(DoubleOps.__int__((double)o)); } if (o is int) { return(o); } if (o is bool) { return(((bool)o) ? 1 : 0); } if (o is BigInteger) { int res; if (((BigInteger)o).AsInt32(out res)) { return(ScriptingRuntimeHelpers.Int32ToObject(res)); } return(o); } if ((el = o as Extensible <BigInteger>) != null) { int res; if (el.Value.AsInt32(out res)) { return(ScriptingRuntimeHelpers.Int32ToObject(res)); } return(el.Value); } if (o is float) { return(DoubleOps.__int__((double)(float)o)); } if (o is Complex) { throw PythonOps.TypeError("can't convert complex to int; use int(abs(z))"); } if (o is Int64) { Int64 val = (Int64)o; if (Int32.MinValue <= val && val <= Int32.MaxValue) { return((Int32)val); } else { return((BigInteger)val); } } else if (o is UInt32) { UInt32 val = (UInt32)o; if (val <= Int32.MaxValue) { return((Int32)val); } else { return((BigInteger)val); } } else if (o is UInt64) { UInt64 val = (UInt64)o; if (val <= Int32.MaxValue) { return((Int32)val); } else { return((BigInteger)val); } } else if (o is Decimal) { Decimal val = (Decimal)o; if (Int32.MinValue <= val && val <= Int32.MaxValue) { return((Int32)val); } else { return((BigInteger)val); } } else if (o is Enum) { return(((IConvertible)o).ToInt32(null)); } Extensible <string> es = o as Extensible <string>; if (es != null) { // __int__ takes precedence, call it if it's available... object value; if (PythonTypeOps.TryInvokeUnaryOperator(DefaultContext.Default, es, "__int__", out value)) { return(value); } // otherwise call __new__ on the string value return(__new__(null, es.Value, 10)); } object result; int intRes; BigInteger bigintRes; if (PythonTypeOps.TryInvokeUnaryOperator(context, o, "__int__", out result) && !Object.ReferenceEquals(result, NotImplementedType.Value)) { if (result is int || result is BigInteger || result is Extensible <int> || result is Extensible <BigInteger> ) { return(result); } else { throw PythonOps.TypeError("__int__ returned non-Integral (type {0})", PythonTypeOps.GetOldName(result)); } } else if (PythonOps.TryGetBoundAttr(context, o, "__trunc__", out result)) { result = PythonOps.CallWithContext(context, result); if (result is int || result is BigInteger || result is Extensible <int> || result is Extensible <BigInteger> ) { return(result); } else if (Converter.TryConvertToInt32(result, out intRes)) { return(intRes); } else if (Converter.TryConvertToBigInteger(result, out bigintRes)) { return(bigintRes); } else { throw PythonOps.TypeError("__trunc__ returned non-Integral (type {0})", PythonTypeOps.GetOldName(result)); } } if (o is OldInstance) { throw PythonOps.AttributeError("{0} instance has no attribute '__trunc__'", PythonTypeOps.GetOldName((OldInstance)o)); } else { throw PythonOps.TypeError("int() argument must be a string or a number, not '{0}'", PythonTypeOps.GetName(o)); } }
public static int Compare(BigInteger x, Extensible<double> y) { return -((int)DoubleOps.Compare(y.Value, x)); }
public void Entry_Order() { Extensible extensibleInfo = new Extensible(); LexEntry entry4 = this._builder.GetOrMakeEntry(extensibleInfo, 4); this._builder.FinishEntry(entry4); LexEntry entry1 = this._builder.GetOrMakeEntry(extensibleInfo, 1); this._builder.FinishEntry(entry1); LexEntry entry2 = this._builder.GetOrMakeEntry(extensibleInfo, 2); this._builder.FinishEntry(entry2); _exporter.Add(entry4, 3); _exporter.Add(entry1, 1); _exporter.Add(entry2, 2); _exporter.End(); AssertXPathNotNull("//entry[@order='1']"); AssertXPathNotNull("//entry[@order='2']"); AssertXPathNotNull("//entry[@order='3']"); }
public void SenseGetsPictureWithCaption() { Extensible extensibleInfo = new Extensible(); LexEntry e = MakeSimpleEntry(); LexSense s = _builder.GetOrMakeSense(e, extensibleInfo, string.Empty); LiftMultiText caption = new LiftMultiText(); caption["aa"] = new LiftString("acaption"); _builder.MergeInPicture(s, "testPicture.png", caption); PictureRef pict = s.GetProperty<PictureRef>("Picture"); Assert.AreEqual("testPicture.png", pict.Value); Assert.AreEqual("acaption", pict.Caption["aa"]); }
private static Extensible AddDates(Extensible extensibleInfo) { extensibleInfo.CreationTime = Extensible.ParseDateTimeCorrectly("2003-08-07T08:42:42Z"); extensibleInfo.ModificationTime = Extensible.ParseDateTimeCorrectly("2005-01-01T01:11:11+8:00"); return extensibleInfo; }
public void Construct_CreationTimeSameAsModifiedTime() { Extensible e = new Extensible(); Assert.IsTrue(e.CreationTime == e.ModificationTime); }
public void Construct_GuidIsNotEmpty() { Extensible e = new Extensible(); Assert.IsTrue(e.Guid != Guid.Empty); }
public void Construct_CreationTimeRecent() { Extensible e = new Extensible(); // created less than one second ago Assert.Less(DateTime.UtcNow - e.CreationTime, new TimeSpan(0, 0, 1)); }
IExtension IExtensible.GetExtensionObject(bool createIfMissing) { return(Extensible.GetExtensionObject(ref this.extensionObject, createIfMissing)); }
private DynamicMetaObject TryToCharConversion(DynamicMetaObject /*!*/ self) { DynamicMetaObject res; // we have an implicit conversion to char if the // string length == 1, but we can only represent // this is implicit via a rule. string strVal = self.Value as string; Expression strExpr = self.Expression; if (strVal == null) { Extensible <string> extstr = self.Value as Extensible <string>; if (extstr != null) { strVal = extstr.Value; strExpr = Ast.Property( AstUtils.Convert( strExpr, typeof(Extensible <string>) ), typeof(Extensible <string>).GetProperty("Value") ); } } // we can only produce a conversion if we have a string value... if (strVal != null) { self = self.Restrict(self.GetRuntimeType()); Expression getLen = Ast.Property( AstUtils.Convert( strExpr, typeof(string) ), typeof(string).GetProperty("Length") ); if (strVal.Length == 1) { res = new DynamicMetaObject( Ast.Call( AstUtils.Convert(strExpr, typeof(string)), typeof(string).GetMethod("get_Chars"), AstUtils.Constant(0) ), self.Restrictions.Merge(BindingRestrictions.GetExpressionRestriction(Ast.Equal(getLen, AstUtils.Constant(1)))) ); } else { res = new DynamicMetaObject( this.Throw( Ast.Call( typeof(PythonOps).GetMethod(nameof(PythonOps.TypeError)), AstUtils.Constant("expected string of length 1 when converting to char, got '{0}'"), Ast.NewArrayInit(typeof(object), self.Expression) ), ReturnType ), self.Restrictions.Merge(BindingRestrictions.GetExpressionRestriction(Ast.NotEqual(getLen, AstUtils.Constant(1)))) ); } } else { // let the base class produce the rule res = null; } return(res); }
static void TestWriteNull <T>() where T : IExtTest, IExtensible, new() { Extensible.AppendValue <string>(null, 1, "hi"); }
static void TestReadNull <T>() where T : IExtTest, IExtensible, new() { string hi = Extensible.GetValue <string>(null, 1); }
private static Extensible CreateFullextensibleInfo(Guid g) { Extensible extensibleInfo = new Extensible(); extensibleInfo.Guid = g; extensibleInfo = AddDates(extensibleInfo); return extensibleInfo; }
public void NewEntry_YesDefYesGloss_BothUnchanged() { Extensible extensibleInfo = new Extensible(); LexEntry e = _builder.GetOrMakeEntry(extensibleInfo, 0); LexSense s = _builder.GetOrMakeSense(e, new Extensible(), string.Empty); _builder.MergeInGloss(s, new LiftMultiText("x", "x gloss")); _builder.MergeInDefinition(s, new LiftMultiText("x", "x def")); _builder.FinishEntry(e); Assert.AreEqual("x gloss", e.Senses[0].Gloss.GetExactAlternative("x")); Assert.AreEqual("x def", e.Senses[0].Definition.GetExactAlternative("x")); }
public void SenseGetsPictureNoCaption() { Extensible extensibleInfo = new Extensible(); LexEntry e = MakeSimpleEntry(); LexSense s = _builder.GetOrMakeSense(e, extensibleInfo, string.Empty); _builder.MergeInPicture(s, "testPicture.png", null); PictureRef pict = s.GetProperty<PictureRef>("Picture"); Assert.AreEqual("testPicture.png", pict.Value); Assert.IsNull(pict.Caption); }
public void NewEntry_NoGlossNoDef_GetNeitherInTheSense() { Extensible extensibleInfo = new Extensible(); LexEntry e = _builder.GetOrMakeEntry(extensibleInfo, 0); LexSense s = _builder.GetOrMakeSense(e, new Extensible(), string.Empty); _builder.FinishEntry(e); Assert.AreEqual(0,e.Senses[0].Gloss.Count); Assert.AreEqual(0, e.Senses[0].Definition.Count); }
public void GetOrMakeEntry_ReturnedLexEntryIsDirty() { Extensible extensibleInfo = new Extensible(); LexEntry entry = _builder.GetOrMakeEntry(extensibleInfo, 0); Assert.IsTrue(entry.IsDirty); }
public void NewEntryWithTextIdIgnoresIt() { Extensible extensibleInfo = new Extensible(); extensibleInfo.Id = "hello"; LexEntry e = _builder.GetOrMakeEntry(extensibleInfo, 0); //no attempt is made to use that id Assert.IsNotNull(e.Guid); Assert.AreNotSame(Guid.Empty, e.Guid); }
public void NewEntryTakesGivenDates() { Extensible extensibleInfo = new Extensible(); extensibleInfo = AddDates(extensibleInfo); LexEntry e = _builder.GetOrMakeEntry(extensibleInfo, 0); Assert.AreEqual(extensibleInfo.CreationTime, e.CreationTime); Assert.AreEqual(extensibleInfo.ModificationTime, e.ModificationTime); }
public void SenseGetsExample() { LexSense sense = new LexSense(); Extensible x = new Extensible(); LexExampleSentence ex = _builder.GetOrMakeExample(sense, x); Assert.IsNotNull(ex); _builder.MergeInExampleForm(ex, MakeBasicLiftMultiText()); Assert.AreEqual(2, ex.Sentence.Forms.Length); Assert.AreEqual("dos", ex.Sentence["ws-two"]); }
private LexEntry MakeSimpleEntry() { Extensible extensibleInfo = new Extensible(); return _builder.GetOrMakeEntry(extensibleInfo, 0); }
public void SenseGetsId() { Extensible extensibleInfo = new Extensible(); extensibleInfo.Id = "foo"; LexSense s = _builder.GetOrMakeSense(new LexEntry(), extensibleInfo, string.Empty); Assert.AreEqual(extensibleInfo.Id, s.Id); }
public static object __new__(CodeContext context, PythonType cls, Extensible<double> o) { object value; // always succeeds as float defines __int__ PythonTypeOps.TryInvokeUnaryOperator(context, o, "__int__", out value); if (cls == TypeCache.Int32) { return (int)value; } else { return cls.CreateInstance(context, value); } }
public static int Compare(BigInteger x, [NotNull] Extensible <double> y) { return(-((int)DoubleOps.Compare(y.Value, x))); }