public void DumpOuterClassWithNoTypeHintPropagatesToInnerClasses()
{
var outerClass = new OuterClass();
outerClass.inner = new InnerClass();
Assert.AreEqual("{\"inner\":{}}", Json.ToJson(outerClass));
}
public void WhatChanged_WhenInnerPropertyChangedFromNull_ShouldReturnThePropertyNamePlusPath()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
//Arrange
var doc = new OuterClass
{
A = "outerValue",
InnerClass = new InnerClass
{
A = null
}
};
const string id = "docs/1";
session.Store(doc, id);
session.SaveChanges();
doc.InnerClass.A = "newInnerValue";
//Action
var changes = session.Advanced.WhatChanged();
//Assert
var changedPaths = changes[id]
.Select(c => c.FieldPath)
.ToList();
var pathsExpected = new[] { "InnerClass" };
RavenTestHelper.AreEquivalent(pathsExpected, changedPaths);
}
}
}
static void Main()
{
new T_NormalTemplateNormalClass().tmethod(new NormalClass());
new OuterClass().T_OuterTMethodNormalClass(new NormalClass());
TemplateFuncs tf = new TemplateFuncs();
if (tf.T_TemplateFuncs1Int(-10) != -10)
{
throw new Exception("it failed");
}
if (tf.T_TemplateFuncs2Double(-12.3) != -12.3)
{
throw new Exception("it failed");
}
T_NestedOuterTemplateDouble tn = new T_NestedOuterTemplateDouble();
if (tn.hohum(-12.3) != -12.3)
{
throw new Exception("it failed");
}
T_OuterClassInner1Int inner1 = new OuterClass().useInner1(new T_OuterClassInner1Int());
T_OuterClassInner2NormalClass inner2 = new T_OuterClassInner2NormalClass();
inner2.embeddedVar = 2;
T_OuterClassInner2NormalClass inner22 = new OuterClass().useInner2Again(inner2);
}
public void WhatChanged_WhenInMatrixChanged_ShouldReturnWithRelevantPath()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
//Arrange
var doc = new OuterClass()
{
InnerClassMatrix = new[] { new[] { new InnerClass {
A = "oldValue"
} } }
};
const string id = "docs/1";
session.Store(doc, id);
session.SaveChanges();
doc.InnerClassMatrix[0][0].A = "newValue";
//Action
var changes = session.Advanced.WhatChanged();
//Assert
var changedPaths = changes[id]
.Select(c => c.FieldPath)
.ToList();
var pathsExpected = new[] { "InnerClassMatrix[0][0]" };
RavenTestHelper.AreEquivalent(pathsExpected, changedPaths);
}
}
}
public static void Main()
{
var sw = Stopwatch.StartNew();
for (int i = 0; i < N; ++i)
{
int x = OuterClass.GetNumber();
string s = OuterClass.GetString();
}
sw.Stop();
TimeSpan outerTime = sw.Elapsed;
sw.Reset();
sw.Start();
for (int i = 0; i < N; ++i)
{
int x = InnerClass.GetNumber();
string s = InnerClass.GetString();
}
sw.Stop();
TimeSpan innerTime = sw.Elapsed;
Console.WriteLine("Outer took {0:0.00} ms.", outerTime.TotalMilliseconds);
Console.WriteLine("Inner took {0:0.00} ms.", innerTime.TotalMilliseconds);
}
public C04AnyInterface()
{
var a1 = new OuterClass <IInnerInterface>();
var a2 = new InnerClass();
a1.Method(a2);
}
public void TestDumpOuterNoTypeHint()
{
var outerClass = new OuterClass();
outerClass.inner = new InnerClass();
Assert.AreEqual("{\"inner\":{\"@type\":\"" + typeof(InnerClass).FullName + "\"}}", JSON.Dump(outerClass, EncodeOptions.NoTypeHints));
}
public C01IdentityConversion()
{
var a1 = new OuterClass <InnerClass>();
var a2 = new InnerClass();
a1.Method(a2);
}
public C02EffectiveBaseClass()
{
var a1 = new OuterClass <InnerClassParent>();
var a2 = new InnerClassChild();
a1.Method(a2);
}
public void TestDumpOuterClassWithNoTypeHintPropagatesToInnerClasses()
{
var outerClass = new OuterClass();
outerClass.inner = new InnerClass();
Assert.AreEqual("{\"inner\":{}}", JSON.Dump(outerClass, EncodeOptions.NoTypeHints));
}
public async Task CorrectPropertyChainGenerated()
{
var outerClass = new OuterClass {
InnerClass = new InnerClass {
InnerInnerClass = new InnerInnerClass {
InnerInnerInnerClass = new InnerInnerInnerClass
{
Property = "Hello"
}
}
}
};
var validator = new OuterClassValidator();
var validationReport = await validator.Validate(outerClass);
validationReport.IsValid.ShouldBeFalse();
var violations = validationReport.Violations.ToArray();
var error1 = ReflectionHelper.PropertyChainToString(violations[0].Property, '.');
error1.ShouldEqual("InnerClass.InnerInnerClass.InnerInnerInnerClass.Property");
}
public C03AnyBaseClass()
{
var a1 = new OuterClass <InnerClassGrandparent>();
var a2 = new InnerClassChild();
a1.Method(a2);
}
public void A_nested_object_should_be_properly_serialized()
{
var message = new OuterClass {
Inner = new InnerClass {
Name = "Chris"
}
};
TestSerialization(message);
}
public void WhatChanged_WhenAllNamedAPropertiesChanged_ShouldReturnDifferentPaths()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
//Arrange
var doc = new OuterClass()
{
A = "outerValue",
InnerClass = new InnerClass
{
A = "innerValue",
},
MiddleClass = new MiddleClass
{
A = null
},
InnerClasses = new[] { new InnerClass {
A = "oldValue"
} },
InnerClassMatrix = new[] { new[] { new InnerClass {
A = "oldValue"
} } }
};
const string id = "docs/1";
session.Store(doc, id);
session.SaveChanges();
doc.A = "newOuterValue";
doc.InnerClass.A = "newInnerValue";
doc.MiddleClass.A = new InnerClass();
doc.InnerClasses[0].A = "newValue";
doc.InnerClassMatrix[0][0].A = "newValue";
//Action
var changes = session.Advanced.WhatChanged();
//Assert
var changedPaths = changes[id]
.Select(c => c.FieldPath)
.ToList();
var pathsExpected = new[]
{
"",
"InnerClass",
"MiddleClass",
"InnerClasses[0]",
"InnerClassMatrix[0][0]"
};
RavenTestHelper.AreEquivalent(pathsExpected, changedPaths);
}
}
}
public static void main(String[] args)
{
// Creates a reference of our outer class
NewClass myClass = new OuterClass();
// Uses it to create an instance of the nestled class
OuterClass.Nested nested = OuterClass.new Nested();
// Uses the nestled class object to instantiate an inner nestled object
OuterClass.Nested.InnerNested inner = nested.new InnerNested();
}
public bool Equals(OuterClass other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(Equals(other.Inner, Inner));
}
public void DumpOuterClassWithNoTypeHintPropagatesToInnerClasses()
{
var outerClass = new OuterClass();
outerClass.inner = new InnerClass();
var nson = Nson.ToNson(outerClass);
Assert.AreEqual("Nez.Persistence.NsonTests.ClassTypeTests+OuterClass(inner:Nez.Persistence.NsonTests.ClassTypeTests+InnerClass())", nson);
var back = Nson.FromNson(nson);
Assert.IsTrue(back.GetType() == typeof(OuterClass));
}
public void Should_not_throw_a_null_reference_exception()
{
Expression <Func <OuterClass, object> > accessor = o => o.Inner.Value;
var writer = SafeProperty.Create(accessor);
const string expected = "Hello";
var subject = new OuterClass();
writer.Set(subject, 0, expected);
Assert.AreEqual(expected, subject.Inner.Value);
}
public void Should_create_a_backing_list_for_list_based_properties()
{
Expression<Func<OuterClass, object>> accessor = o => o.Inners[0].Value;
SafeProperty writer = accessor.CreateSafeProperty();
const string expected = "Hello";
var subject = new OuterClass();
writer.Set(subject, 0, expected);
subject.Inners.ShouldNotBeNull();
subject.Inners[0].Value.ShouldEqual(expected);
}
public void Should_create_a_backing_list_for_list_based_properties()
{
Expression <Func <OuterClass, object> > accessor = o => o.Inners[0].Value;
SafeProperty writer = accessor.CreateSafeProperty();
const string expected = "Hello";
var subject = new OuterClass();
writer.Set(subject, 0, expected);
subject.Inners.ShouldNotBeNull();
subject.Inners[0].Value.ShouldEqual(expected);
}
internal static void NestedClass()
{
//throw new NotImplementedException();
new OuterClass().Execute();
// ALL CLASS MEMBERS ARE PRIVATE BY DEFAULT.
//NestedClass nested = new NestedClass();
OuterClass outer = new OuterClass();
// MUST FULLY QUALIFY FROM OUTER TO ACCESS NESTED.
OuterClass.NestedClass nested = outer.CreateObjectOfNestedClass();
nested.Execute();
}
public void Should_create_a_backing_list_for_list_based_properties()
{
Expression<Func<OuterClass, object>> accessor = o => o.Inners[0].Value;
var writer = SafeProperty.Create(accessor);
const string expected = "Hello";
var subject = new OuterClass();
writer.Set(subject, 0, expected);
Assert.IsNotNull(subject.Inners);
Assert.AreEqual(expected, subject.Inners[0].Value);
}
public void Should_create_a_backing_list_for_list_based_properties()
{
Expression <Func <OuterClass, object> > accessor = o => o.Inners[0].Value;
var writer = SafeProperty.Create(accessor);
const string expected = "Hello";
var subject = new OuterClass();
writer.Set(subject, 0, expected);
Assert.IsNotNull(subject.Inners);
Assert.AreEqual(expected, subject.Inners[0].Value);
}
public void Should_create_a_setter_for_a_simple_value()
{
Expression <Func <OuterClass, object> > accessor = o => o.Value;
SafeProperty writer = accessor.CreateSafeProperty();
var subject = new OuterClass();
const string expected = "Hello";
writer.Set(subject, 0, expected);
subject.Value.ShouldEqual(expected);
}
public void Should_create_a_setter_for_a_simple_value()
{
Expression <Func <OuterClass, object> > accessor = o => o.Value;
var writer = SafeProperty.Create(accessor);
var subject = new OuterClass();
const string expected = "Hello";
writer.Set(subject, 0, expected);
Assert.AreEqual(expected, subject.Value);
}
public void Should_allow_property_to_already_be_set()
{
Expression<Func<OuterClass, object>> accessor = o => o.Inner.Value;
var writer = SafeProperty.Create(accessor);
const string expected = "Hello";
var subject = new OuterClass();
subject.Inner = new InnerClass {OtherValue = "Hi"};
writer.Set(subject, 0, expected);
Assert.AreEqual(expected, subject.Inner.Value);
Assert.AreEqual("Hi", subject.Inner.OtherValue);
}
static void Main() {
new T_NormalTemplateNormalClass().tmethod(new NormalClass());
new OuterClass().T_OuterTMethodNormalClass(new NormalClass());
TemplateFuncs tf = new TemplateFuncs();
if (tf.T_TemplateFuncs1Int(-10) != -10)
throw new Exception("it failed");
if (tf.T_TemplateFuncs2Double(-12.3) != -12.3)
throw new Exception("it failed");
T_NestedOuterTemplateDouble tn = new T_NestedOuterTemplateDouble();
if (tn.hohum(-12.3) != -12.3)
throw new Exception("it failed");
OuterClass.T_OuterClassInner1Int inner1 = new OuterClass().useInner1(new OuterClass.T_OuterClassInner1Int());
OuterClass.T_OuterClassInner2NormalClass inner2 = new OuterClass.T_OuterClassInner2NormalClass();
inner2.embeddedVar = 2;
OuterClass.T_OuterClassInner2NormalClass inner22 = new OuterClass().useInner2Again(inner2);
}
// Main method
public void testNestedClass()
{
// Create the instance of outer class
OuterClass outer = new OuterClass();
outer.method1();
// This statement gives an error because
// you are not allowed to access inner
// class methods with outer class objects
// obj1. method2();
// Creating an instance of inner class
OuterClass.InnerClass iner = new OuterClass.InnerClass();
// Accessing the method of inner class
iner.method2();
}
public void Should_allow_property_to_already_be_set()
{
Expression <Func <OuterClass, object> > accessor = o => o.Inner.Value;
var writer = SafeProperty.Create(accessor);
const string expected = "Hello";
var subject = new OuterClass();
subject.Inner = new InnerClass {
OtherValue = "Hi"
};
writer.Set(subject, 0, expected);
Assert.AreEqual(expected, subject.Inner.Value);
Assert.AreEqual("Hi", subject.Inner.OtherValue);
}
static void Main(string[] args)
{
PublicClass pub = new PublicClass();
PublicClassPrivateProp pubpriv = new PublicClassPrivateProp();
PublicClassGetSet pubgetset = new PublicClassGetSet();
OuterClass outer = new OuterClass();
OuterClass.TestProtected outerprotectedtest = new OuterClass.TestProtected();
OuterProtectedTestClass outerprotectedderivedtest = new OuterProtectedTestClass();
// Access the public property of the PublicClass class
pub.PublicProperty = "setting public property to value";
Console.WriteLine(pub.PublicProperty);
// Try to access the private property of the PublicClassPrivateProp class
// pubpriv
// Access the properties with get and set from the PublicClassGetSet class
pubgetset.OnlySet = "new value 1";
Console.WriteLine(pubgetset.OnlyGet);
pubgetset.Both = "new value 2";
Console.WriteLine(pubgetset.Both);
// Try to access the private classes nested inside the outer class
//outer
// Access the protected OuterClassProtected class from class within OuterClass
Console.WriteLine(outerprotectedtest.GetString());
// Use a derived class to access the protected OuterClassProtected class, this class is outside the OuterClass
Console.WriteLine(outerprotectedderivedtest.GetString());
Console.WriteLine("Press ENTER to exit");
Console.ReadLine();
}
public InnerClass(OuterClass o)
{
o_ = o;
}
public void TestDumpOuterNoTypeHint()
{
var outerClass = new OuterClass();
outerClass.inner = new InnerClass();
Assert.AreEqual( "{\"inner\":{\"@type\":\"" + typeof( InnerClass ).FullName + "\"}}", JSON.Dump( outerClass, EncodeOptions.NoTypeHints ) );
}
public void Should_create_a_setter_for_a_simple_value()
{
Expression<Func<OuterClass, object>> accessor = o => o.Value;
SafeProperty writer = accessor.CreateSafeProperty();
var subject = new OuterClass();
const string expected = "Hello";
writer.Set(subject, 0, expected);
subject.Value.ShouldEqual(expected);
}
public InnerClass(OuterClass outerClass)
{
outerClass.i = 1;
outerClass.j = 1;
outerClass.k = 1;
}
public void Should_create_a_setter_for_a_simple_value()
{
Expression<Func<OuterClass, object>> accessor = o => o.Value;
var writer = SafeProperty.Create(accessor);
var subject = new OuterClass();
const string expected = "Hello";
writer.Set(subject, 0, expected);
Assert.AreEqual(expected, subject.Value);
}
public void Should_not_throw_a_null_reference_exception()
{
Expression<Func<OuterClass, object>> accessor = o => o.Inner.Value;
var writer = SafeProperty.Create(accessor);
const string expected = "Hello";
var subject = new OuterClass();
writer.Set(subject, 0, expected);
Assert.AreEqual(expected, subject.Inner.Value);
}
static void Main(string[] args)
{
OuterClass TestOne = new OuterClass();
InnerClass TestTwo = new InnerClass(); // does not compile
}
public ContainerClass2([TestContract("c2")] OuterClass outerClass)
{
this.outerClass = outerClass;
}
public static void abc()
{
OuterClass oc = new OuterClass();
System.Console.WriteLine(oc.y);
}
