public static void Main( string[] args )
{
// Create instance and call template method
ConcreteClass c = new ConcreteClass();
c.TemplateMethod();
}
public void DuckedTypeCannotGetPrivateProperty()
{
var a = new ConcreteClass();
var duck = a.Duck<IProtectedInterface>();
duck.ProtectedData = "test";
}
public void TestOAuth2Scopes()
{
var scopes = new JsonDictionary();
scopes.Add("https://www.example.com/auth/one", new Scope()
{
ID = "https://www.example.com/auth/one"
});
scopes.Add("https://www.example.com/auth/two", new Scope()
{
ID = "https://www.example.com/auth/two"
});
var oauth2 = new JsonDictionary()
{
{ "scopes", scopes }
};
var auth = new JsonDictionary()
{
{ "oauth2", oauth2 }
};
var dict = new JsonDictionary()
{
{ "auth", auth }, { "name", "TestName" }, { "version", "v1" }
};
IService impl = new ConcreteClass(dict);
Assert.IsNotNull(impl.Scopes);
Assert.AreEqual(2, impl.Scopes.Count);
Assert.IsTrue(impl.Scopes.ContainsKey("https://www.example.com/auth/one"));
Assert.IsTrue(impl.Scopes.ContainsKey("https://www.example.com/auth/two"));
}
public void TestSimpleGetters()
{
var dict = new JsonDictionary();
dict.Add("name", "TestName");
dict.Add("version", "v1");
dict.Add("description", "Test Description");
dict.Add("documentationLink", "https://www.google.com/");
dict.Add("features", new List <object> {
"feature1", "feature2"
});
dict.Add("labels", new List <object> {
"label1", "label2"
});
dict.Add("id", "TestId");
dict.Add("title", "Test API");
IService impl = new ConcreteClass(dict);
Assert.AreEqual("Test Description", impl.Description);
Assert.AreEqual("https://www.google.com/", impl.DocumentationLink);
MoreAsserts.ContentsEqualAndInOrder(new List <string> {
"feature1", "feature2"
}, impl.Features);
MoreAsserts.ContentsEqualAndInOrder(new List <string> {
"label1", "label2"
}, impl.Labels);
Assert.AreEqual("TestId", impl.Id);
Assert.AreEqual("Test API", impl.Title);
}
public void Test_Patch_ConcreteClass()
{
var instance = new Harmony("special-case-1");
Assert.NotNull(instance, "instance");
var processor = instance.CreateClassProcessor(typeof(ConcreteClass_Patch));
Assert.NotNull(processor, "processor");
var someStruct1 = new ConcreteClass().Method("test", new AnotherStruct());
Assert.True(someStruct1.accepted, "someStruct1.accepted");
TestTools.Log($"Patching ConcreteClass_Patch start");
var replacements = processor.Patch();
Assert.NotNull(replacements, "replacements");
Assert.AreEqual(1, replacements.Count);
TestTools.Log($"Patching ConcreteClass_Patch done");
TestTools.Log($"Running patched ConcreteClass_Patch start");
var someStruct2 = new ConcreteClass().Method("test", new AnotherStruct());
Assert.True(someStruct2.accepted, "someStruct2.accepted");
TestTools.Log($"Running patched ConcreteClass_Patch done");
}
public void DuckedTypeCannotGetPrivateEvent()
{
var a = new ConcreteClass();
var duck = a.Duck<IProtectedInterfaceWithEvent>();
duck.ProtectedEvent += (sender, args) => args.ToString();
}
public void TestCommonParameters()
{
const string testJson =
@"{
'fields': {
'type': 'string',
'description': 'Selector specifying which fields to include in a partial response.',
'location': 'query'
},
'prettyPrint': {
'type': 'boolean',
'description': 'Returns response with indentations and line breaks.',
'default': 'true',
'location': 'query'
},
}";
var paramDict = Google.Apis.Json.JsonReader.Parse(testJson.Replace('\'', '\"')) as JsonDictionary;
var dict = new JsonDictionary()
{
{ "parameters", paramDict },
{ "name", "TestName" },
{ "version", "v1" }
};
var impl = new ConcreteClass(dict);
Assert.That(impl.Parameters.Count, Is.EqualTo(2));
Assert.That(impl.Parameters.Keys,
Is.EquivalentTo(new string[] { "fields", "prettyPrint" }));
var prettyPrint = impl.Parameters["prettyPrint"];
Assert.That(prettyPrint.Description,
Is.EqualTo("Returns response with indentations and line breaks."));
Assert.That(prettyPrint.ValueType, Is.EqualTo("boolean"));
}
public void DuckedTypeCannotGetPrivateMethod()
{
var a = new ConcreteClass();
var duck = a.Duck<IProtectedInterfaceWithMethod>();
duck.ProtectedMethod();
}
static void Main(string[] args)
{
ConcreteClass instance = new ConcreteClass();
instance.Method();
Console.ReadKey();
}
static void Main(string[] args)
{
IInterface II = new ConcreteClass();
II.FunctionA();
II.FunctionB();
II.FunctionC();
}
public void DuckedTypeCanGetProperty()
{
var a = new ConcreteClass();
var duck = a.Duck<ITest>();
a.Tuple = new Tuple<string, int>("test", 1);
Assert.AreEqual(a.Tuple.Item1, duck.Tuple.Item1);
}
static void Main(string[] args)
{
Abstract a = new ConcreteClass();
Abstract b = new ConcreteClassB();
a.TemplateMethod();
b.TemplateMethod();
}
static void Main(string[] args)
{
ConcreteClass concreteClass = new ConcreteClass();
//Upcast needed
IInterface1 interface1 = concreteClass as IInterface1;
interface1.Method();
}
static void Main(string[] args)
{
AbstractClass instance = new ConcreteClass();
instance.Method();
// Delay
Console.ReadKey();
}
public void GetTheSameConcreteClassTwiceFromCreate()
{
AutoMocker <ConcreteClass> autoMocker = createAutoMocker <ConcreteClass>();
ConcreteClass concreteClass = autoMocker.ClassUnderTest;
Assert.AreSame(concreteClass, autoMocker.ClassUnderTest);
Assert.AreSame(concreteClass, autoMocker.ClassUnderTest);
Assert.AreSame(concreteClass, autoMocker.ClassUnderTest);
}
static void Main()
{
ConcreteClass instance = new ConcreteClass();
instance.Method();
// Delay.
Console.ReadKey();
}
public void UseTheAutoMockerToStartUpTheConcreteClassAsAPartialMockAndSetTheNameMethodUp()
{
AutoMocker <ConcreteClass> autoMocker = createAutoMocker <ConcreteClass>();
autoMocker.PartialMockTheClassUnderTest();
ConcreteClass concreteClass = autoMocker.ClassUnderTest;
setExpectation(concreteClass, x => x.Name, "Max");
concreteClass.Name.ShouldEqual("Max");
}
static void Main(string[] args)
{
ConcreteClass concreteClass = new ConcreteClass();
concreteClass.Method();
IInterface1 interface1 = concreteClass as IInterface1;
interface1.Method();
}
static void Main(string[] args)
{
IInterface II = new ConcreteClass();
II.FunctionA();
II.FunctionB();
II.FunctionC();
Console.Read();
Console.WriteLine("Hello World!");
}
static void Main(string[] args)
{
AbstractClassA inst = new ConcreteClass();
inst.OperationA();
//inst.OperationB(); // Недоступен, т.к. мы приводились к А, т.е. мы инкапсулировали ОперэйшнВ
AbstractClassB instance = new ConcreteClass();
instance.OperationA();
instance.OperationB();
}
/// <summary>
/// Calculate Structural Class based on PN-EN 1992-1-1 Table 4.3N
/// </summary>
public ConcreteCoverOutput CalculateStructuralClass(ConcreteCoverInput inputData)
{
this.inputData = inputData;
ExposureClass exposureClass = ConvertStringToExposureClass(this.inputData.ExposureClass);
ConcreteClass concreteClass = ConvertStringToConcreteClass(this.inputData.ConcreteClass);
this.outputData.StructuralClass = this.inputData.BaseStructuralClass;
// Check Exposure Class
if (exposureClass == ExposureClass.X0 || exposureClass == ExposureClass.XC1 ||
exposureClass == ExposureClass.XC2 || exposureClass == ExposureClass.XC3 ||
exposureClass == ExposureClass.XC4 || exposureClass == ExposureClass.XD1 ||
exposureClass == ExposureClass.XD2 || exposureClass == ExposureClass.XS1 ||
exposureClass == ExposureClass.XD3 || exposureClass == ExposureClass.XS2 ||
exposureClass == ExposureClass.XS3
)
{
// Modification based on Design Working Life of 100 years
if (this.inputData.DesignWorkingLifeOf100Years)
{
//this.StructuralClass = (StructuralClass)((int)StructuralClass + 2).Clamp((int)StructuralClass.S1, (int)StructuralClass.S6);
this.outputData.StructuralClass = ((int)ConvertStringToStructuralClass(this.outputData.StructuralClass) + 2).ToString();
}
// Modification based on Concrete Class and Exposure Class
if ((concreteClass >= ConcreteClass.C30_37 && (exposureClass == ExposureClass.X0 || exposureClass == ExposureClass.XC1)) ||
(concreteClass >= ConcreteClass.C35_45 && (exposureClass == ExposureClass.XC2 || exposureClass == ExposureClass.XC3)) ||
(concreteClass >= ConcreteClass.C40_50 && (exposureClass == ExposureClass.XC4 || exposureClass == ExposureClass.XD1 || exposureClass == ExposureClass.XD2 || exposureClass == ExposureClass.XS1)) ||
(concreteClass >= ConcreteClass.C45_55 && (exposureClass == ExposureClass.XD3 || exposureClass == ExposureClass.XS2 || exposureClass == ExposureClass.XS3)))
{
//this.StructuralClass = (StructuralClass)((int)StructuralClass - 1).Clamp((int)StructuralClass.S1, (int)StructuralClass.S6);
this.outputData.StructuralClass = ((int)ConvertStringToStructuralClass(this.outputData.StructuralClass) - 1).ToString();
}
// Modification based on Member With Slab Geometry
if (this.inputData.MemberWithSlabGeometry)
{
//this.StructuralClass = (StructuralClass)((int)StructuralClass - 1).Clamp((int)StructuralClass.S1, (int)StructuralClass.S6);
this.outputData.StructuralClass = ((int)ConvertStringToStructuralClass(this.outputData.StructuralClass) - 1).ToString();
}
// Modification based on Member With Slab Geometry
if (this.inputData.SpecialQualityControlOfTheConcreteProductionEnsured)
{
//this.StructuralClass = (StructuralClass)((int)StructuralClass - 1).Clamp((int)StructuralClass.S1, (int)StructuralClass.S6);
this.outputData.StructuralClass = ((int)ConvertStringToStructuralClass(this.outputData.StructuralClass) - 1).ToString();
}
}
this.outputData.StructuralClass = ((int)ConvertStringToStructuralClass(this.outputData.StructuralClass)).Clamp((int)StructuralClass.S1, (int)StructuralClass.S6).ToString();
return(this.outputData);
}
public void TestCommonParametersMissing()
{
var paramDict = new JsonDictionary();
var dict = new JsonDictionary()
{
{ "name", "TestName" }, { "version", "v1" }
};
var impl = new ConcreteClass(dict);
Assert.That(impl.Parameters, Is.Not.Null);
Assert.That(impl.Parameters.Count, Is.EqualTo(0));
}
public static void TestGetTypeInAbstract()
{
ConcreteClass test = new ConcreteClass();
Assert.AreEqual(
"Bridge.ClientTest.Batch3.BridgeIssues.Bridge3426+ConcreteClass",
test.TypeProp,
"Property query for instance:abstract class returns the expected class name.");
Assert.AreEqual(
"Bridge.ClientTest.Batch3.BridgeIssues.Bridge3426+ConcreteClass",
test.TypeMethod(),
"Method query returns the expected class name.");
}
public void TheAutoMockerOptionallyPushesInMocksInReplayModeToAllowForAAAsyntax()
{
// This sets up a Rhino Auto Mocker in the Arrange, Act, Assert mode
var autoMocker = new RhinoAutoMocker <ConcreteClass>(MockMode.AAA);
// Act in the test
ConcreteClass @class = autoMocker.ClassUnderTest;
@class.CallService();
// This retrieves the mock object for IMockedService
autoMocker.Get <IMockedService>().AssertWasCalled(s => s.Go());
}
//模板模式调用
public static void GetTemplate()
{
//现在想吃绿色的面，猪肉大葱馅的饺子
AbstractClass fan = new ConcreteClass();
fan.EatDumplings();
Console.WriteLine();
//过了段时间，我开始想吃橙色面的，韭菜鸡蛋馅的饺子
fan = new ConcreteClass2();
fan.EatDumplings();
Console.Read();
}
public void TheAutoMockerPushesInMocksForAllOfTheConstructorArgumentsForAPartialMock()
{
AutoMocker <ConcreteClass> autoMocker = createAutoMocker <ConcreteClass>();
var service = autoMocker.Get <IMockedService>();
var service2 = autoMocker.Get <IMockedService2>();
var service3 = autoMocker.Get <IMockedService3>();
autoMocker.PartialMockTheClassUnderTest();
ConcreteClass concreteClass = autoMocker.ClassUnderTest;
Assert.AreSame(service, concreteClass.Service);
Assert.AreSame(service2, concreteClass.Service2);
Assert.AreSame(service3, concreteClass.Service3);
}
static void Main(string[] args)
{
//现在想吃绿色面的，猪肉大葱馅的饺子
AbstractClass fan = new ConcreteClass();
fan.EatDumplings();
Console.WriteLine();
//过了段时间，我开始想吃橙色面的，韭菜鸡蛋馅的饺子
fan = new ConcreteClass2();
fan.EatDumplings();
Console.Read();
}
public void Custom_Id_In_Interface()
{
var mapper = new BsonMapper();
var obj = new ConcreteClass {
CustomId = "myid", Name = "myname"
};
var doc = mapper.Serialize(obj) as BsonDocument;
doc["_id"].Should().NotBeNull();
doc["_id"].Should().Be("myid");
doc["CustomName"].Should().NotBe(BsonValue.Null);
doc["CustomName"].Should().Be("myname");
doc["Name"].Should().Be(BsonValue.Null);
doc.Keys.ExpectCount(2);
}
public void TheAutoMockerPushesInMocksAndAPreBuiltStubForAllOfTheConstructorArguments()
{
AutoMocker <ConcreteClass> autoMocker = createAutoMocker <ConcreteClass>();
var stub = new StubService();
autoMocker.Inject <IMockedService>(stub);
var service2 = autoMocker.Get <IMockedService2>();
var service3 = autoMocker.Get <IMockedService3>();
ConcreteClass concreteClass = autoMocker.ClassUnderTest;
Assert.AreSame(stub, concreteClass.Service);
Assert.AreSame(service2, concreteClass.Service2);
Assert.AreSame(service3, concreteClass.Service3);
}
static void Main()
{
ConcreteClass instance = new ConcreteClass();
instance.Method();
IInterface1 instance1 = instance as IInterface1;
instance1.Method();
IInterface2 instance2 = instance as IInterface2;
instance2.Method();
// Delay.
Console.ReadKey();
}
public void AbstractClassTableName()
{
ActiveRecordStarter.ResetInitializationFlag();
Assert.IsTrue(NHibernate.Cfg.Environment.UseReflectionOptimizer);
ActiveRecordStarter.Initialize(GetConfigSource(),
typeof(AbstractClass<>),
typeof(ConcreteClass));
Assert.IsFalse(NHibernate.Cfg.Environment.UseReflectionOptimizer);
Recreate();
ConcreteClass c = new ConcreteClass();
c.Save();
Assert.IsTrue(ConcreteClass.FindAll().Length == 1);
}
public void AbstractClassTableName()
{
ActiveRecordStarter.ResetInitializationFlag();
Assert.IsTrue(NHibernate.Cfg.Environment.UseReflectionOptimizer);
ActiveRecordStarter.Initialize(GetConfigSource(),
typeof(AbstractClass<>),
typeof(ConcreteClass));
Assert.IsFalse(NHibernate.Cfg.Environment.UseReflectionOptimizer);
Recreate();
ConcreteClass c = new ConcreteClass();
c.Save();
Assert.IsTrue(ConcreteClass.FindAll().Length == 1);
}
static void Main(string[] args)
{
Console.WriteLine("***Implementing generic interfaces.***\n");
//Using 'int' type
GenericInterface <int> concreteInt = new ConcreteClass <int>();
int myInt = concreteInt.GenericMethod(5);
Console.WriteLine($"The value stored in myInt is : {myInt}");
concreteInt.NonGenericMethod();
//Using 'string' type now
GenericInterface <string> concreteString = new ConcreteClass <string>();
string myStr = concreteString.GenericMethod("Hello Reader");
Console.WriteLine($"The value stored in myStr is : {myInt}");
concreteString.NonGenericMethod();
Console.ReadKey();
}
public void TestBaseUri()
{
ConcreteClass instance = (ConcreteClass)CreateV1Service();
instance.BasePath = "/test/";
instance.ServerUrl = "https://www.test.value/";
Assert.AreEqual("https://www.test.value/test/", instance.BaseUri.ToString());
instance.BasePath = "test/";
instance.ServerUrl = "https://www.test.value/";
Assert.AreEqual("https://www.test.value/test/", instance.BaseUri.ToString());
instance.BasePath = "/test/";
instance.ServerUrl = "https://www.test.value";
Assert.AreEqual("https://www.test.value/test/", instance.BaseUri.ToString());
instance.BasePath = "test/";
instance.ServerUrl = "https://www.test.value";
Assert.AreEqual("https://www.test.value/test/", instance.BaseUri.ToString());
// Mono's Uri class strips double forward slashes so this test will not work.
// Only run for MS.Net
if (Google.Apis.Util.Utilities.IsMonoRuntime() == false)
{
instance.BasePath = "//test/";
instance.ServerUrl = "https://www.test.value";
Assert.AreEqual("https://www.test.value//test/", instance.BaseUri.ToString());
instance.BasePath = "//test/";
instance.ServerUrl = "https://www.test.value/";
Assert.AreEqual("https://www.test.value//test/", instance.BaseUri.ToString());
instance.BasePath = "test/";
instance.ServerUrl = "https://www.test.value//";
Assert.AreEqual("https://www.test.value//test/", instance.BaseUri.ToString());
instance.BasePath = "/test//";
instance.ServerUrl = "https://www.test.value/";
Assert.AreEqual("https://www.test.value/test//", instance.BaseUri.ToString());
}
}
public static void TestGetTypeInSuperClass()
{
ConcreteClass test = new ConcreteClass();
Assert.AreEqual(
"Bridge.ClientTest.Batch3.BridgeIssues.Bridge3426+ConcreteClass",
test.TypeProp,
"Property query for instance:abstract class returns the expected class name.");
Assert.AreEqual(
"Bridge.ClientTest.Batch3.BridgeIssues.Bridge3426+ConcreteClass",
test.TypeMethod(),
"Method query returns the expected class name.");
SuperClass sup = new SuperClass();
Assert.AreEqual("Bridge.ClientTest.Batch3.BridgeIssues.Bridge3426+SuperClass",
sup.TypeProp,
"Property query for direct instance of super class returns the expected name.");
Assert.AreEqual("Bridge.ClientTest.Batch3.BridgeIssues.Bridge3426+SuperClass",
sup.TypeMethod(),
"Method query for direct instance of super class returns the expected name.");
SubClass sub = new SubClass();
Assert.AreEqual("Bridge.ClientTest.Batch3.BridgeIssues.Bridge3426+SubClass",
sub.TypeProp,
"Property query for instance of sub class returns the expected name.");
Assert.AreEqual("Bridge.ClientTest.Batch3.BridgeIssues.Bridge3426+SubClass",
sub.TypeMethod(),
"Method query for instance of sub class returns the expected name.");
SuperClass subCast = (SuperClass)sub;
Assert.AreEqual("Bridge.ClientTest.Batch3.BridgeIssues.Bridge3426+SubClass",
subCast.TypeProp,
"Property query for cast instance of super class returns the expected name.");
Assert.AreEqual("Bridge.ClientTest.Batch3.BridgeIssues.Bridge3426+SubClass",
subCast.TypeMethod(),
"Method query for cast instance of super class returns the expected name.");
}
public void TestMethodsOnService()
{
var testMethod = new JsonDictionary();
testMethod.Add("id", "service.testMethod");
testMethod.Add("path", "service/testMethod");
testMethod.Add("httpMethod", "GET");
var methods = new JsonDictionary()
{
{ "testMethod", testMethod }
};
var dict = new JsonDictionary()
{
{ "methods", methods }, { "name", "TestName" }, { "version", "v1" }
};
IService impl = new ConcreteClass(dict);
Assert.IsNotNull(impl.Methods);
Assert.AreEqual(1, impl.Methods.Count);
Assert.AreEqual("testMethod", impl.Methods["testMethod"].Name);
}
public void TestOAuth2Scopes()
{
var scopes = new JsonDictionary();
scopes.Add("https://www.example.com/auth/one", new Scope() { ID = "https://www.example.com/auth/one" });
scopes.Add("https://www.example.com/auth/two", new Scope() { ID = "https://www.example.com/auth/two" });
var oauth2 = new JsonDictionary() { { "scopes", scopes } };
var auth = new JsonDictionary() { { "oauth2", oauth2 } };
var dict = new JsonDictionary() { { "auth", auth }, { "name", "TestName" }, { "version", "v1" } };
IService impl = new ConcreteClass(dict);
Assert.IsNotNull(impl.Scopes);
Assert.AreEqual(2, impl.Scopes.Count);
Assert.IsTrue(impl.Scopes.ContainsKey("https://www.example.com/auth/one"));
Assert.IsTrue(impl.Scopes.ContainsKey("https://www.example.com/auth/two"));
}
public void DuckedTypeCanAddAndRemoveEventHandler()
{
var a = new ConcreteClass();
var duck = a.Duck<ITest>();
duck.TestEvent += DuckOnTestEvent;
duck.TestEvent -= DuckOnTestEvent;
}
public static void SetDesignPattern(ConcreteClass element, DesignPattern newDesignPattern)
{
DslModeling::DomainRoleInfo.SetLinkedElement(element, ConcreteClassDomainRoleId, newDesignPattern);
}
public void DuckedTypeCallNonReturnMethodWithParameters()
{
var a = new ConcreteClass();
var duck = a.Duck<ITest>();
duck.Temp("");
}
public void DuckedTypeIsInstanceOfInterface()
{
var duck = new ConcreteClass().Duck<ITest>();
Assert.IsInstanceOfType(duck, typeof(ITest));
}
public void DuckedTypeCallNonReturnGenericMethod()
{
var a = new ConcreteClass();
var duck = a.Duck<ITest>();
duck.Temp<string>();
}
public void DuckedTypeCallReturnMethod()
{
var a = new ConcreteClass();
var duck = a.Duck<ITest>();
duck.ATemp();
}
public static DesignPattern GetDesignPattern(ConcreteClass element)
{
return DslModeling::DomainRoleInfo.GetLinkedElement(element, ConcreteClassDomainRoleId) as DesignPattern;
}
public void TestSimpleGetters()
{
var dict = new JsonDictionary();
dict.Add("name", "TestName");
dict.Add("version", "v1");
dict.Add("description", "Test Description");
dict.Add("documentationLink", "https://www.google.com/");
dict.Add("features", new List<object>{ "feature1", "feature2" });
dict.Add("labels", new List<object>{ "label1", "label2" });
dict.Add("id", "TestId");
dict.Add("title", "Test API");
IService impl = new ConcreteClass(dict);
Assert.AreEqual("Test Description", impl.Description);
Assert.AreEqual("https://www.google.com/", impl.DocumentationLink);
MoreAsserts.ContentsEqualAndInOrder(new List<string> { "feature1", "feature2" }, impl.Features);
MoreAsserts.ContentsEqualAndInOrder(new List<string> { "label1", "label2" }, impl.Labels);
Assert.AreEqual("TestId", impl.Id);
Assert.AreEqual("Test API", impl.Title);
}
public AmbiguousConstructorsTestClass(ConcreteClass class1, IDummy dummy1)
{
}
public void TestMethodsOnService()
{
var testMethod = new JsonDictionary();
testMethod.Add("id", "service.testMethod");
testMethod.Add("path", "service/testMethod");
testMethod.Add("httpMethod", "GET");
var methods = new JsonDictionary() { { "testMethod", testMethod } };
var dict = new JsonDictionary() { { "methods", methods }, { "name", "TestName" }, { "version", "v1" } };
IService impl = new ConcreteClass(dict);
Assert.IsNotNull(impl.Methods);
Assert.AreEqual(1, impl.Methods.Count);
Assert.AreEqual("testMethod", impl.Methods["testMethod"].Name);
}
public void AbstractClassTableName()
{
ActiveRecordStarter.ResetInitializationFlag();
ActiveRecordStarter.Initialize(GetConfigSource(),
typeof(AbstractClass<>),
typeof(ConcreteClass));
Recreate();
ConcreteClass c = new ConcreteClass();
c.Save();
Assert.IsTrue(ConcreteClass.FindAll().Length == 1);
}
public void TestCommonParametersMissing()
{
var paramDict = new JsonDictionary();
var dict = new JsonDictionary() { { "name", "TestName" }, { "version", "v1" } };
var impl = new ConcreteClass(dict);
Assert.That(impl.Parameters, Is.Not.Null);
Assert.That(impl.Parameters.Count, Is.EqualTo(0));
}
public DefaultValue()
{
ConcreteClass = new ConcreteClass();
}
public void TestCommonParameters()
{
const string testJson =
@"{
'fields': {
'type': 'string',
'description': 'Selector specifying which fields to include in a partial response.',
'location': 'query'
},
'prettyPrint': {
'type': 'boolean',
'description': 'Returns response with indentations and line breaks.',
'default': 'true',
'location': 'query'
},
}";
var paramDict = Google.Apis.Json.JsonReader.Parse(testJson.Replace('\'', '\"')) as JsonDictionary;
var dict = new JsonDictionary() {
{ "parameters", paramDict},
{ "name", "TestName" },
{ "version", "v1" } };
var impl = new ConcreteClass(dict);
Assert.That(impl.Parameters.Count, Is.EqualTo(2));
Assert.That(impl.Parameters.Keys,
Is.EquivalentTo(new string[] { "fields", "prettyPrint" }));
var prettyPrint = impl.Parameters["prettyPrint"];
Assert.That(prettyPrint.Description,
Is.EqualTo("Returns response with indentations and line breaks."));
Assert.That(prettyPrint.ValueType, Is.EqualTo("boolean"));
}
public void DuckedTypeCallReturnGenericMethodWithParameters()
{
var a = new ConcreteClass();
var duck = a.Duck<ITest>();
duck.ATemp<string>("");
}
public void DuckedTypeIsNotNull()
{
var duck = new ConcreteClass().Duck<ITest>();
Assert.IsNotNull(duck);
}
public void DuckedTypeCanAddEventHandler()
{
var a = new ConcreteClass();
var duck = a.Duck<ITest>();
duck.TestEvent += (sender, args) => { };
}
/// <summary>
/// Constructor
/// Creates a DesignPatternHasConcreteClasses link in the same Partition as the given DesignPattern
/// </summary>
/// <param name="source">DesignPattern to use as the source of the relationship.</param>
/// <param name="target">ConcreteClass to use as the target of the relationship.</param>
public DesignPatternHasConcreteClasses(DesignPattern source, ConcreteClass target)
: base((source != null ? source.Partition : null), new DslModeling::RoleAssignment[]{new DslModeling::RoleAssignment(DesignPatternHasConcreteClasses.DesignPatternDomainRoleId, source), new DslModeling::RoleAssignment(DesignPatternHasConcreteClasses.ConcreteClassDomainRoleId, target)}, null)
{
}