public void Can_Generate_Correct_Temporary_Index()
{
using (var store = base.NewDocumentStore("munin", false))
{
using (var s = store.OpenSession())
{
// store the element
Outer outer = new Outer {
Inner = new Inner {
Flag = true
}
};
s.Store(outer);
s.SaveChanges();
}
using (var s = store.OpenSession())
{
// query by the inner flag
Outer outer = s.Query <Outer>()
.Customize(x => x.WaitForNonStaleResults())
.Where(o => o.Inner.Flag).SingleOrDefault();
Assert.NotNull(outer); // this fails
}
}
}
/// <summary>
/// Returns an instance of <see cref="IPolygon"/> representing this GeoJSON polygon.
/// </summary>
/// <returns>An instance of <see cref="IPolygon"/>.</returns>
public IPolygon ToPolygon()
{
IEnumerable <IPoint> outer = Outer.Select(x => x.ToPoint());
IEnumerable <IEnumerable <IPoint> > inner = Inner.Select(x => x.Select(y => y.ToPoint()));
return(new Polygon(outer, inner));
}
public void QueryingUsingObjects()
{
using (var store = GetDocumentStore(new Options()
{
ModifyDocumentStore = documentStore =>
documentStore.Conventions.CustomizeJsonSerializer = serializer => serializer.TypeNameHandling = TypeNameHandling.All
}))
{
using (var session = store.OpenSession())
{
var obj = new Outer {
Examples = new List <IExample>()
{
new Example {
Provider = "Test", Id = "Abc"
}
}
};
session.Store(obj);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var ex = new Example {
Provider = "Test", Id = "Abc"
};
var arr = session.Query <Outer>().Customize(c => c.WaitForNonStaleResults())
.Where(o => o.Examples.Any(e => e == ex))
.ToArray();
//WaitForUserToContinueTheTest(store);
Assert.Equal(1, arr.Length);
}
}
}
static void Main() {
Outer outer = new Outer();
outer.a = 1;
outer.b = 2;
Outer.InnerStruct1 is1 = outer.makeInnerStruct1();
Outer.InnerClass1 ic1 = outer.makeInnerClass1();
Outer.InnerUnion1 iu1 = outer.makeInnerUnion1();
Outer.InnerStruct2 is2 = outer.makeInnerStruct2();
Outer.InnerClass2 ic2 = outer.makeInnerClass2();
Outer.InnerUnion2 iu2 = outer.makeInnerUnion2();
Outer.InnerClass4Typedef ic4 = outer.makeInnerClass4Typedef();
Outer.InnerStruct4Typedef is4 = outer.makeInnerStruct4Typedef();
Outer.InnerUnion4Typedef iu4 = outer.makeInnerUnion4Typedef();
Outer.InnerClass5Typedef ic5 = outer.makeInnerClass5();
Outer.InnerStruct5Typedef is5 = outer.makeInnerStruct5();
Outer.InnerUnion5Typedef iu5 = outer.makeInnerUnion5();
ic5 = outer.makeInnerClass5Typedef();
is5 = outer.makeInnerStruct5Typedef();
iu5 = outer.makeInnerUnion5Typedef();
{
Outer.InnerMultiple im1 = outer.MultipleInstance1;
Outer.InnerMultiple im2 = outer.MultipleInstance2;
Outer.InnerMultiple im3 = outer.MultipleInstance3;
Outer.InnerMultiple im4 = outer.MultipleInstance4;
}
{
Outer.InnerMultipleDerived im1 = outer.MultipleDerivedInstance1;
Outer.InnerMultipleDerived im2 = outer.MultipleDerivedInstance2;
Outer.InnerMultipleDerived im3 = outer.MultipleDerivedInstance3;
Outer.InnerMultipleDerived im4 = outer.MultipleDerivedInstance4;
}
{
Outer.InnerMultipleDerived im1 = outer.MultipleDerivedInstance1;
Outer.InnerMultipleDerived im2 = outer.MultipleDerivedInstance2;
Outer.InnerMultipleDerived im3 = outer.MultipleDerivedInstance3;
Outer.InnerMultipleDerived im4 = outer.MultipleDerivedInstance4;
}
{
Outer.InnerMultipleAnonTypedef1 mat1 = outer.makeInnerMultipleAnonTypedef1();
Outer.InnerMultipleAnonTypedef1 mat2 = outer.makeInnerMultipleAnonTypedef2();
SWIGTYPE_p_p_Outer__InnerMultipleAnonTypedef1 mat3 = outer.makeInnerMultipleAnonTypedef3();
Outer.InnerMultipleNamedTypedef1 mnt = outer.makeInnerMultipleNamedTypedef();
Outer.InnerMultipleNamedTypedef1 mnt1 = outer.makeInnerMultipleNamedTypedef1();
Outer.InnerMultipleNamedTypedef1 mnt2 = outer.makeInnerMultipleNamedTypedef2();
SWIGTYPE_p_p_Outer__InnerMultipleNamedTypedef mnt3 = outer.makeInnerMultipleNamedTypedef3();
}
{
Outer.InnerSameName isn = outer.makeInnerSameName();
}
}
//
public BrainProxy GetBrain()
{
BrainProxy brain;
brain = Client.InternBrain(Outer.GetBrain(Guid));
return(brain);
}
public override void OnEnteringState()
{
base.OnEnteringState();
Outer.CurrentActivity = m_StateActivity;
Outer.OnActivityChanged(new ActivityChangedEventArgs(m_StateActivity));
}
static void Main()
{
var outer = new Outer(new Inner(10));
Console.WriteLine(outer.InnerObject.Value);
var value = outer.InnerObject.Value;
}
public void QueryingUsingObjects()
{
using (var store = GetDocumentStore(new Options()
{
ModifyDocumentStore = documentStore =>
documentStore.Conventions.RegisterQueryValueConverter <object>(TryConvertValueForQueryDelegate, RangeType.None)
}))
{
using (var session = store.OpenSession())
{
var obj = new Outer {
Examples = new List <IExample>()
{
new Example {
Provider = "Test", Id = "Abc"
}
}
};
session.Store(obj);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var ex = new Example {
Provider = "Test", Id = "Abc"
};
var arr = session.Query <Outer>().Customize(c => c.WaitForNonStaleResults())
.Where(o => o.Examples.Any(e => e == ex))
.ToArray();
//WaitForUserToContinueTheTest(store);
Assert.Equal(1, arr.Length);
}
}
}
public void InnerFieldsDictionary()
{
var validationService = new ValidationService();
var target = new Outer()
{
Licenses2 = new Dictionary<string,DriversLicense> {
{ "first",
new DriversLicense()
{
Number = "TX"
}
}
}
};
try
{
Validator.ValidateObject(target, Factories.BuildValidationContext(target), true);
Assert.Fail("Should have thrown an Exception.");
}
catch (ValidationException ex)
{
var results = (ex.ValidationResult as IEnumerable<ValidationResult>).Flatten(result => result as IEnumerable<ValidationResult>, leafNodesOnly: true);
Assert.IsTrue((from entry in results
from member in entry.MemberNames
select member + ": " + entry.ErrorMessage).SequenceEqual(new[]
{
"Licenses2[0].Value.Number: Licenses2 Number Invalid",
"Licenses2[0].Value.State: Licenses2 State Required",
}));
}
}
public void QueryingUsingObjects()
{
using (var store = NewDocumentStore())
{
store.Conventions.CustomizeJsonSerializer += serializer =>
{
serializer.TypeNameHandling = TypeNameHandling.All;
};
using (var session = store.OpenSession())
{
var obj = new Outer { Examples = new List<IExample>() { new Example { Provider = "Test", Id = "Abc" } } };
session.Store(obj);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var ex = new Example { Provider = "Test", Id = "Abc" };
var arr = session.Query<Outer>().Customize(c => c.WaitForNonStaleResults())
.Where(o => o.Examples.Any(e => e == ex))
.ToArray();
WaitForUserToContinueTheTest(store);
Assert.Equal(1, arr.Length);
}
}
}
//
// function that does nested exception stuff
//
static void DoExceptionStuff()
{
int c;
int i = 0;
try
{
//div by 0 exception
c = 6 / i;
Console.WriteLine("**** Error: Should NOT Reach This Code ****");
}
catch (Exception Outer)
{
Console.WriteLine("**** Outer Exception was Handled ****");
Console.WriteLine(Outer.ToString());
Console.WriteLine();
try
{
throw new ArgumentException("Bad Arguments");
Console.WriteLine("**** Error: Should NOT Reach This Code ****");
}
catch (ArgumentException Inner)
{
Console.WriteLine("**** Inner Exception was Handled ****");
Console.WriteLine(Inner.ToString());
Console.WriteLine();
}
}
finally
{
Console.WriteLine("**** Leaving Finally ****");
Console.WriteLine();
}
}
public void CommitOuter()
{
if (disposed)
{
throw new ObjectDisposedException($"{nameof(TransactionManager<TInner, TOuter>)}");
}
if (complete || outerComplete)
{
throw new InvalidOperationException("Outer Transaction already completed!");
}
if (timedOut)
{
throw new InvalidOperationException("Transaction timed out!");
}
try
{
//outerComplete = true;
//complete = innerComplete && outerComplete;
Outer.Commit();
}
catch (TransactionException txEx)
{
Log.Debug("Outer Commit transaction failed.");
Rollback();
throw new TransactionException("Outer Commit transaction failed", txEx);
}
}
public void ExceptionSerializer_NestedReferenceCycle()
{
// Throw an exception so that is has a stack trace.
var exception = GetNewException();
var expected = new Outer
{
SomeFunObject = exception.OtherField,
Object = exception,
};
// Create a reference cycle.
exception.SomeObject = expected;
var bytes = MessagePackSerializer.Serialize(expected, WithExceptionResolver.Instance);
var actual = MessagePackSerializer.Deserialize <Outer>(bytes, WithExceptionResolver.Instance);
Assert.Equal(expected.Object.BaseField.Value, actual.Object.BaseField.Value, StringComparer.Ordinal);
Assert.Equal(expected.Object.SubClassField, actual.Object.SubClassField, StringComparer.Ordinal);
Assert.Equal(expected.Object.OtherField.Value, actual.Object.OtherField.Value, StringComparer.Ordinal);
// Check for referential equality in the fields which happened to be reference-equals.
Assert.Equal(actual.Object.BaseField, actual.Object.OtherField, ReferenceEqualsComparer.Instance);
Assert.Equal(actual, actual.Object.SomeObject, ReferenceEqualsComparer.Instance);
Assert.Equal(actual.SomeFunObject, actual.Object.OtherField, ReferenceEqualsComparer.Instance);
}
public void ExceptionSerializer_NestedReferenceCycle()
{
// Throw an exception so that is has a stack trace.
var exception = GetNewException();
var expected = new Outer
{
SomeFunObject = exception.OtherField,
Object = exception,
};
// Create a reference cycle.
exception.SomeObject = expected;
var writer = new BinaryTokenStreamWriter();
this.environment.SerializationManager.Serialize(expected, writer);
var reader = new DeserializationContext(this.environment.SerializationManager)
{
StreamReader = new BinaryTokenStreamReader(writer.ToByteArray())
};
var actual = (Outer)this.environment.SerializationManager.Deserialize(null, reader.StreamReader);
Assert.Equal(expected.Object.BaseField.Value, actual.Object.BaseField.Value, StringComparer.Ordinal);
Assert.Equal(expected.Object.SubClassField, actual.Object.SubClassField, StringComparer.Ordinal);
Assert.Equal(expected.Object.OtherField.Value, actual.Object.OtherField.Value, StringComparer.Ordinal);
// Check for referential equality in the fields which happened to be reference-equals.
Assert.Equal(actual.Object.BaseField, actual.Object.OtherField, ReferenceEqualsComparer.Instance);
Assert.Equal(actual, actual.Object.SomeObject, ReferenceEqualsComparer.Instance);
Assert.Equal(actual.SomeFunObject, actual.Object.OtherField, ReferenceEqualsComparer.Instance);
}
/// <summary>
/// Return geometry for a particular representation item.
/// </summary>
/// <param name="shapeEditScope">The shape edit scope.</param>
/// <param name="lcs">Local coordinate system for the geometry, without scale.</param>
/// <param name="scaledLcs">Local coordinate system for the geometry, including scale, potentially non-uniform.</param>
/// <param name="guid">The guid of an element for which represntation is being created.</param>
/// <returns>The created geometry.</returns>
protected override IList <GeometryObject> CreateGeometryInternal(
IFCImportShapeEditScope shapeEditScope, Transform lcs, Transform scaledLcs, string guid)
{
// since IFCAdvancedBrep must contain a closed shell, we set the BuildPreferenceType to be solid for now
for (int pass = 0; pass < 2; pass++)
{
using (BuilderScope bs = shapeEditScope.InitializeBuilder(IFCShapeBuilderType.BrepBuilder))
{
BrepBuilderScope brepBuilderScope = bs as BrepBuilderScope;
BRepType brepType = (pass == 0) ? BRepType.Solid : BRepType.OpenShell;
brepBuilderScope.StartCollectingFaceSet(brepType);
Outer.AllowInvalidFace = (pass == 0);
Outer.CreateShape(shapeEditScope, lcs, scaledLcs, guid);
IList <GeometryObject> geomObjs = null;
geomObjs = brepBuilderScope.CreateGeometry();
// We'll return only if we have geometry; otherwise we'll try again with looser validation, if we can.
if (geomObjs != null)
{
if (pass == 1)
{
Importer.TheLog.LogError(Id, "Some faces are missing from this Solid; reading in as an Open Shell instead.", false);
}
return(geomObjs);
}
}
}
return(null);
}
public void StringMethodWiths()
{
Outer outer = new Outer();
outer.Inner = new Inner();
outer.Inner.Prop = string.Empty;
_mock.Expects.One.MethodWith(_ => _.Method <string>(), "1014").Comment("");
_mock.Expects.One.MethodWith(_ => _.Get <string>("140"), "1015").Comment("");
_mock.Expects.One.MethodWith(_ => _.MethodVoid <string>(string.Empty));
_mock.Expects.One.MethodWith(_ => _.MethodVoid <string>(outer.Inner.Prop));
outer.Inner.Prop = "testing";
_mock.Expects.One.MethodWith(_ => _.MethodVoid <string>(outer.Inner.Prop));
_mock.Expects.One.MethodWith(_ => _.MethodVoid <string>(Outer.CONST));
_mock.Expects.One.MethodWith(_ => _.MethodVoid <string>(outer.Inner.CONST));
_mock.Expects.One.MethodWith(_ => _.MethodVoid <string>(outer.Inner.GetString()));
_mock.Expects.One.MethodWith(_ => _.MethodVoid <string>(new Outer {
Inner = new Inner {
Prop = "dynamic"
}
}.Inner.Prop));
//_mock.Expects.One.MethodWith(_ => _.MethodVoid<string>(() => { return string.Empty; }));
Assert.AreEqual("1014", _mock.MockObject.Method <string>());
Assert.AreEqual("1015", _mock.MockObject.Get <string>("140"));
_mock.MockObject.MethodVoid <string>(string.Empty);
_mock.MockObject.MethodVoid <string>(string.Empty);
_mock.MockObject.MethodVoid <string>("testing");
_mock.MockObject.MethodVoid <string>("Constant");
_mock.MockObject.MethodVoid <string>("Constant1");
_mock.MockObject.MethodVoid <string>("Method");
_mock.MockObject.MethodVoid <string>("dynamic");
}
/// <summary>
/// Get interface information from the ccw server(outer), and cache them in local.
/// 1) store the "interface <-> Class"
/// 2) store the "Method Name <-> DispID"
/// 3) store the "DispID <-> MethodInfo"
/// </summary>
/// <param name="interfaceType"></param>
private void PullInInterface(Type interfaceType)
{
if (interfaceType == null)
{
throw new ArgumentNullException("Pass in parameter should not be null");
}
Console.WriteLine("Try to pull in the interface info for " + interfaceType);
// 1) store the "interface <-> Class"
Type classType = Outer.GetAggregatedClassFromInterface(interfaceType);
interfaceClassDictionary.Add(interfaceType, classType);
object o = Outer.GetAggregatedInstanceFromClass(classType);
classInstanceDictionary[classType] = o;
// store all the method information
MethodInfo[] methods = interfaceType.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
foreach (MethodInfo mi in methods)
{
int id = NewDispId();
Console.WriteLine("Pull in " + mi.Name + " with ID " + id);
// 2) store the "Method Name <-> DispID"
methodNameIDDictionary.Add(mi.Name, id);
// 3) store the "DispID <-> MethodInfo"
methodIDInfoDictionary.Add(id, mi);
}
}
public Symbol Resolve(string identifier)
{
var symbol = Store.Where(pair => pair.Key == identifier).FirstOrDefault();
if (!symbol.Equals(default(KeyValuePair <string, Symbol>)))
{
return(symbol.Value);
}
if (Outer != default(SymbolTable))
{
var outerSymbol = Outer.Resolve(identifier);
if (outerSymbol == Symbol.Undefined || outerSymbol.Scope == SymbolScope.Global)
{
return(outerSymbol);
}
else
{
var free = new Symbol {
Name = outerSymbol.Name, Index = Frees.Count, Scope = SymbolScope.Free
};
Store[outerSymbol.Name] = free;
Frees[free.Name] = outerSymbol;
return(free);
}
}
return(Symbol.Undefined);
}
protected override void Because_of()
{
_source = new Outer {
Foo = new Inner()
};
_dest = Mapper.Map <Outer>(_source);
}
public void ShouldOrderNestedTypes()
{
var ordered = new Outer[]
{
new Outer(),
new Outer
{
Value = "001 No inner",
},
new Outer
{
Value = "002 With inner",
Inner = new Inner(),
},
new Outer
{
Value = "003 With inner",
Inner = new Inner
{
Name = "With value",
},
},
}
.OrderBy("(Inner==null||Inner.Name==null?String(null):String(Inner.Name)) Asc,Value desc");
Assert.AreEqual("002 With inner", ordered.First().Value);
Assert.AreEqual("003 With inner", ordered.Last().Value);
}
public void try_to_query()
{
using (var session = theStore.OpenSession())
{
var outer = new Outer();
outer.Inners.Add(new Inner()
{
Type = "T1", Value = "V11"
});
outer.Inners.Add(new Inner()
{
Type = "T1", Value = "V12"
});
outer.Inners.Add(new Inner()
{
Type = "T2", Value = "V21"
});
session.Store(outer);
session.SaveChanges();
}
using (var session2 = theStore.OpenSession())
{
// This works
var o1 = session2.Query <Outer>().FirstOrDefault(o => o.Inners.Any(i => i.Type == "T1" && i.Value == "V12"));
o1.ShouldNotBeNull();
var o2 = session2.Query(new FindOuterByInner("T1", "V12"));
o2.ShouldNotBeNull();
o2.Id.ShouldBe(o1.Id);
}
}
public void InnerFieldsDictionary()
{
var validationService = new ValidationService();
var target = new Outer()
{
Licenses2 = new Dictionary <string, DriversLicense> {
{ "first",
new DriversLicense()
{
Number = "TX"
} }
}
};
try
{
Validator.ValidateObject(target, Factories.BuildValidationContext(target), true);
Assert.Fail("Should have thrown an Exception.");
}
catch (ValidationException ex)
{
var results = (ex.ValidationResult as IEnumerable <ValidationResult>).Flatten(result => result as IEnumerable <ValidationResult>, leafNodesOnly: true);
Assert.IsTrue((from entry in results
from member in entry.MemberNames
select member + ": " + entry.ErrorMessage).SequenceEqual(new[]
{
"Licenses2[0].Value.Number: Licenses2 Number Invalid",
"Licenses2[0].Value.State: Licenses2 State Required",
}));
}
}
//Callbacks
private void OnProcessCreated(Process process)
{
Guid contextId = Service.Intern(process);
Guid parentId;
if (process.Parent != null)
{
parentId = process.Parent.Guid;
}
else
{
parentId = contextId;
}
string label;
if (process.Proposal.Message.Clause != null)
{
label = process.Proposal.Message.Clause.ToString();
}
else
{
label = "Root";
}
Outer.OnContextCreated(Guid, contextId, parentId, label);
}
//[Fact] -- TODO, there's a GH issue to bring this back when the containment operator is replaced
public void Bug_503_child_collection_query_in_compiled_query()
{
using (var session = theStore.OpenSession())
{
var outer = new Outer();
outer.Inners.Add(new Inner()
{
Type = "T1", Value = "V11"
});
outer.Inners.Add(new Inner()
{
Type = "T1", Value = "V12"
});
outer.Inners.Add(new Inner()
{
Type = "T2", Value = "V21"
});
session.Store(outer);
session.SaveChanges();
}
using (var session2 = theStore.OpenSession())
{
// This works
var o1 = session2.Query <Outer>().FirstOrDefault(o => o.Inners.Any(i => i.Type == "T1" && i.Value == "V12"));
SpecificationExtensions.ShouldNotBeNull(o1);
var o2 = session2.Query(new FindOuterByInner("T1", "V12"));
SpecificationExtensions.ShouldNotBeNull(o2);
o2.Id.ShouldBe(o1.Id);
}
}
public override void Write(Utf8JsonWriter writer, Outer <T> value, JsonSerializerOptions options)
{
writer.WriteStartObject();
writer.WriteString("S", value.S);
writer.WritePropertyName("C");
JsonSerializer.Serialize(writer, value.C, typeof(T), options);
writer.WriteEndObject();
}
public override string GetStepParameters()
{
var parameters = new List<string>();
parameters.Add(Outer != null ? Outer.ToStepValue() : "$");
parameters.Add(Voids != null ? Voids.ToStepValue() : "$");
return string.Join(", ", parameters.ToArray());
}
public void Reverse()
{
Outer.Reverse();
bOuterIsCW = Outer.IsClockwise;
foreach (var h in Holes)
{
h.Reverse();
}
}
public void Translate(Vector2 t)
{
Outer.Translate(t);
foreach (var hole in Holes)
{
hole.Translate(t);
}
}
IEnumerable <T2> foo9 <T2>(T2 t2, Outer <T2> .Mid <T2> x, Outer <T2> .Mid <T2> .Inner1 y, Outer <T2> .Mid <T2> .Inner2 <T2> z)
where T2 : Valuable <T2>
{
x.bar3(); z.bar2(); y.bar1(); z.bar4(t2); y.bar5(t2); x.bar6(t2);
for (int i = 0; i < t2.IntValue; i++)
{
yield return(t2);
}
}
public void ReduceByMinDistance(float minDistance, int minVertexCount = 3)
{
Outer.ReduceByMinDistance(minDistance, minVertexCount);
foreach (var hole in Holes)
{
hole.ReduceByMinDistance(minDistance, minVertexCount);
}
}
public void Scale(float s)
{
Outer.Scale(s);
foreach (var hole in Holes)
{
hole.Scale(s);
}
}
public void ReduceByMinTriangleArea(float minArea, int minVertexCount = 3)
{
Outer.ReduceByMinTriangleArea(minArea, minVertexCount);
foreach (var hole in Holes)
{
hole.ReduceByMinTriangleArea(minArea, minVertexCount);
}
}
public void ReduceCodirected(float minAngle, int minVertexCount = 3)
{
Outer.ReduceCodirected(minAngle, minVertexCount);
foreach (var hole in Holes)
{
hole.ReduceCodirected(minAngle, minVertexCount);
}
}
public void Should_set_first_level_property()
{
Expression<Func<Outer, string>> expression = o => o.Value;
SafeProperty setter = SafeProperty.Create(expression);
var outer = new Outer();
setter.Set(outer, 0, "Hello");
Assert.AreEqual("Hello", outer.Value);
}
static void Main()
{
dele d = m1;
d("정적 메서드");
CSTest CS = new CSTest();
d = CS.m2;
d("인스턴스 메서드");
d = Outer.m3;
d("외부 정적 메서드");
Outer O = new Outer();
d = O.m4;
d("외부 인스턴스 메서드");
}
public void Should_set_third_level_value_with_one_array_indexer()
{
Expression<Func<Outer, string>> expression = o => o.Middles[0].Inner.Value;
SafeProperty setter = SafeProperty.Create(expression);
var outer = new Outer();
setter.Set(outer, 0, "Hello");
Assert.IsNotNull(outer.Middles);
Assert.AreEqual(1, outer.Middles.Count);
Assert.IsNotNull(outer.Middles[0].Inner);
Assert.AreEqual("Hello", outer.Middles[0].Inner.Value);
}
public void Should_not_crater_the_planet()
{
var outer = new Outer();
outer.Inners = new Inner[2]
{
new Inner {Parent = outer, Value = "First"},
new Inner {Parent = outer, Value = "Second"},
};
var builder = new RoutingSlipBuilder(Guid.NewGuid());
Assert.Throws<JsonSerializationException>(() =>
builder.AddActivity("Activity", new Uri("loopback://localhost/execute_activity"), new
{
Content = outer,
}));
}
static void Main() {
{
Inner inner = new Inner(5);
Outer outer = new Outer();
Inner newInner = outer.doubleInnerValue(inner);
if (newInner.getValue() != 10)
throw new Exception("inner failed");
}
{
Outer outer = new Outer();
Inner inner = outer.createInner(3);
Inner newInner = outer.doubleInnerValue(inner);
if (outer.getInnerValue(newInner) != 6)
throw new Exception("inner failed");
}
}
static void Main() {
Outer outer = new Outer();
nested_structs.setValues(outer, 10);
Outer_inner1 inner1 = outer.inner1;
Outer_inner1 inner2 = outer.inner2;
Outer_inner1 inner3 = outer.inner3;
Outer_inner1 inner4 = outer.inner4;
if (inner1.val != 10) throw new Exception("failed inner1");
if (inner2.val != 20) throw new Exception("failed inner2");
if (inner3.val != 20) throw new Exception("failed inner3");
if (inner4.val != 40) throw new Exception("failed inner4");
Named inside1 = outer.inside1;
Named inside2 = outer.inside2;
Named inside3 = outer.inside3;
Named inside4 = outer.inside4;
if (inside1.val != 100) throw new Exception("failed inside1");
if (inside2.val != 200) throw new Exception("failed inside2");
if (inside3.val != 200) throw new Exception("failed inside3");
if (inside4.val != 400) throw new Exception("failed inside4");
}
public void Can_Generate_Correct_Temporary_Index()
{
using (var store = NewDocumentStore())
{
using (var s = store.OpenSession())
{
// store the element
Outer outer = new Outer { Inner = new Inner { Flag = true } };
s.Store(outer);
s.SaveChanges();
}
using (var s = store.OpenSession())
{
// query by the inner flag
Outer outer = s.Query<Outer>()
.Customize(x => x.WaitForNonStaleResults())
.Where(o => o.Inner.Flag).SingleOrDefault();
Assert.NotNull(outer); // this fails
}
}
}
public async Task WithNestedField(IYield gen)
{
var data = new Outer { InnerThing = new Outer.Inner() };
data.InnerThing.Field = (string)await gen.Yield();
await gen.Yield(data.InnerThing.Field);
}
public async Task WithNestedProperty(IYield gen)
{
var data = new Outer { InnerThing = new Outer.Inner() };
data.InnerThing.Property = (string)await gen.Yield();
await gen.Yield(data.InnerThing.Property);
}
protected override void Because_of()
{
_source = new Outer { Foo = new Inner() };
_dest = Mapper.Map<Outer>(_source);
}
public static bool Test1 (Outer Outer)
{
return 0 == Outer.Inner.ONE;
}
public static void Go() {
using (var stream = new MemoryStream()) {
BinaryFormatter formatter = new BinaryFormatter();
var outer = new Outer { inner = new Inner() };
//Circle[] circles = new[] { new Circle(10), new Circle(20) };
formatter.Serialize(stream, outer);
stream.Position = 0;
outer = (Outer)formatter.Deserialize(stream);
}
}
public void IgnoreNullTest()
{
var target = new Outer();
Validator.ValidateObject(target, new ValidationContext(target));
}
protected override void Because_of()
{
var outer = new Outer { Inner = new Inner() { Prop1 = "Prop1" } };
Mapper.Map<Outer, OuterDTO>(outer, o => o.AfterMap((s, d) => _afterMapCalled = true));
}
