private void DoTestNestedGenerics <TKey, TValue>(TKey[] arg, Dictionary <TKey, TValue> expectedRetval)
{
var handler = CreateClass("MyService", "NestedGenerics")(new[] { typeof(TKey), typeof(TValue) });
var argCodec = codecContainer.GetManualCodecFor <TKey[]>();
var resultCodec = codecContainer.GetManualCodecFor <Dictionary <TKey, TValue> >();
var data = new byte[argCodec.CalculateSize(arg)];
fixed(byte *pData = data)
{
var p = pData;
argCodec.Encode(ref p, arg);
}
var expectedData = new byte[resultCodec.CalculateSize(expectedRetval)];
fixed(byte *pData = expectedData)
{
var p = pData;
resultCodec.Encode(ref p, expectedRetval);
}
service.NestedGenerics <TKey, TValue>(arg).ReturnsForAnyArgs(expectedRetval);
var result = handler.Handle(service, data, 0).Result;
var serviceCall = service.ReceivedCalls().Last();
Assert.That(serviceCall.GetMethodInfo(), Is.EqualTo(typeof(IGlobalService).GetMethod("NestedGenerics").MakeGenericMethod(new[] { typeof(TKey), typeof(TValue) })));
Assert.That(serviceCall.GetArguments()[0], Is.EquivalentTo(arg));
Assert.That(result, Is.EquivalentTo(expectedData));
}
public void ReferenceInRef()
{
var handler = CreateClass("MyService", "ReferenceInRef")(null);
var data = new byte[4];
var expectedData = new byte[8];
fixed(byte *pData = expectedData)
{
*(int *)pData = 4;
*(char *)(pData + 4) = 'O';
*(char *)(pData + 6) = 'K';
}
string s = "";
service.WhenForAnyArgs(x => x.ReferenceInRef(ref s)).Do(x =>
{
x[0] = "OK";
});
var result = handler.Handle(service, data, 0).Result;
Assert.That(result, Is.EquivalentTo(expectedData));
}
public void MixedParameterTypes()
{
var handler = CreateClass("MyService", "MixedParameterTypes")(null);
var data = new byte[8];
fixed(byte *pData = data)
{
*(int *)pData = 123;
*(bool *)(pData + 4) = false;
}
var expectedData = new byte[14];
fixed(byte *pData = expectedData)
{
*(bool *)pData = true;
*(ushort *)(pData + 4) = 246;
*(double *)(pData + 6) = 123.456;
}
bool dummyBool = false;
ushort dummyUshort;
service.MixedParameterTypes(0, ref dummyBool, out dummyUshort).ReturnsForAnyArgs(x =>
{
x[1] = true;
x[2] = (ushort)((int)x[0] * 2);
return(123.456);
});
var result = handler.Handle(service, data, 0).Result;
Assert.That(result, Is.EquivalentTo(expectedData));
}
public void Ref()
{
var handler = CreateClass("MyService", "ModifyByRef")(null);
var data = new byte[8];
fixed(byte *pData = data)
{
*(double *)pData = 12.34;
}
var expectedData = new byte[8];
fixed(byte *pData = expectedData)
{
*(double *)pData = 24.68;
}
double dummy = 0;
service.WhenForAnyArgs(x => x.ModifyByRef(ref dummy)).Do(x => { x[0] = (double)x[0] * 2; });
var result = handler.Handle(service, data, 0).Result;
Assert.That(result, Is.EquivalentTo(expectedData));
}
private void DoTestMixedGenerics <T1, T2, T3>(int argA, T1 expectedRetval, T1 argB, T2 argC, T2 expectedC, T3 expectedD)
{
var handler = CreateClass("MyService", "MixedGenerics")(new[] { typeof(T1), typeof(T2), typeof(T3) });
var intCodec = codecContainer.GetManualCodecFor <int>();
var t1Codec = codecContainer.GetManualCodecFor <T1>();
var t2Codec = codecContainer.GetManualCodecFor <T2>();
var t3Codec = codecContainer.GetManualCodecFor <T3>();
var data = new byte[intCodec.CalculateSize(argA) + t1Codec.CalculateSize(argB) + t2Codec.CalculateSize(argC)];
fixed(byte *pData = data)
{
var p = pData;
intCodec.Encode(ref p, argA);
t1Codec.Encode(ref p, argB);
t2Codec.Encode(ref p, argC);
}
var expectedData = new byte[t2Codec.CalculateSize(expectedC) + t3Codec.CalculateSize(expectedD) + t1Codec.CalculateSize(expectedRetval)];
fixed(byte *pData = expectedData)
{
var p = pData;
t2Codec.Encode(ref p, expectedC);
t3Codec.Encode(ref p, expectedD);
t1Codec.Encode(ref p, expectedRetval);
}
T2 dummyC = default(T2);
T3 dummyD;
int realA = default(int);
T1 realB = default(T1);
T2 realC = default(T2);
service.MixedGenerics(0, default(T1), ref dummyC, out dummyD).ReturnsForAnyArgs(x =>
{
realA = (int)x[0];
realB = (T1)x[1];
realC = (T2)x[2];
x[2] = expectedC;
x[3] = expectedD;
return(expectedRetval);
});
var result = handler.Handle(service, data, 0).Result;
var serviceCall = service.ReceivedCalls().Last();
Assert.That(serviceCall.GetMethodInfo(), Is.EqualTo(typeof(IGlobalService).GetMethod("MixedGenerics").MakeGenericMethod(new[] { typeof(T1), typeof(T2), typeof(T3) })));
Assert.That(realA, Is.EqualTo(argA));
Assert.That(realB, Is.EqualTo(argB));
Assert.That(realC, Is.EqualTo(argC));
Assert.That(result, Is.EquivalentTo(expectedData));
}
public void Trivial()
{
var handler = CreateClass("MyService", "Trivial")(null);
var result = handler.Handle(service, null, 0).Result;
Assert.That(result.Length, Is.EqualTo(0));
Assert.That(service.ReceivedCalls().Single().GetMethodInfo().Name, Is.EqualTo("Trivial"));
}
private void DoTestEmptyGeneric <T>()
{
var handler = CreateClass("MyService", "EmptyGeneric")(new[] { typeof(T) });
handler.Handle(service, null, 0);
var serviceCall = service.ReceivedCalls().Last();
Assert.That(serviceCall.GetMethodInfo(), Is.EqualTo(typeof(IGlobalService).GetMethod("EmptyGeneric").MakeGenericMethod(new[] { typeof(T) })));
}
public void SubService()
{
var middleService = Substitute.For <IMiddleService>();
service.Middle.Returns(middleService);
var handler = CreateClass("MyService", "Middle", "Trivial")(null);
handler.Handle(service, null, 0);
Assert.That(middleService.ReceivedCalls().Single().GetMethodInfo().Name, Is.EqualTo("Trivial"));
}
public void VoidAsync()
{
var handler = CreateClass("MyService", "VoidAsync")(null);
var task = new Task(() => { });
task.Start();
service.VoidAsync().Returns(task);
var resultingTask = handler.Handle(service, null, 0);
Assert.That(resultingTask.Result, Is.EqualTo(new byte[0]));
}
public override Verb CreateVerb(string[] tokens)
{
if (!InClassDefinition)
{
return(null);
}
Color(position, tokens[1].Length, KeyWords);
var name = tokens[2];
Color(name.Length, Variables);
var parameterLength = tokens[3].Length;
Color(parameterLength, Structures);
var index = position + length;
var parameters = new Parameters();
if (parameterLength > 0)
{
var parametersParser = new ParametersParser();
var newIndex = parametersParser.Parse(source, index);
if (!newIndex.If(out parameters, out index))
{
return(null);
}
}
overridePosition = index;
var builder = new CodeBuilder();
if (parameters.Length == 0)
{
var mangledName = MangledName(name);
var cls = new Class(parameters, objectBlock(name), new Block(), ClassName, new string[0], new Parameters(), false);
var verb = new CreateClass(mangledName, cls);
builder.Verb(verb);
builder.End();
builder.Push();
builder.FunctionInvoke(mangledName);
builder.AssignToNewField(true, name, builder.Pop(true), global: true);
builder.End();
}
else
{
var cls = new Class(parameters, objectBlock(name), new Block(), ClassName, new string[0], new Parameters(), false);
var verb = new CreateClass(name, cls);
builder.Verb(verb);
}
if (HelperBlock == null)
{
HelperBlock = new Block();
}
foreach (var verb in builder.Block.AsAdded)
{
HelperBlock.Add(verb);
}
return(new NullOp());
}
public void Create()
{
var _class = new Class(parameters, objectBlock, classBlock, superName, traitNames.ToArray(), superParameters,
LockedDown);
CreateClass.Create(className, _class, helperFunctions, helperBlock);
}
/// <summary>
/// Display the Activity workspace form.
/// </summary>
/// <param name="type"></param>
public void ShowActivityWorkspace(string type)
{
if (type == "Student")
{
RegistrationController registerController = new RegistrationController(this.db, this);
List <Class> classes = db.GetClasses();
RegisterForClassForm registerForm = new RegisterForClassForm(this, registerController, classes);
registerController.registerForm = registerForm;
ClassWorksheet classWorksheet = new ClassWorksheet((StudentAccount)this.GetLoggedInUser());
registerController.classWorksheet = classWorksheet;
RegisterForClass activityWindow = new RegisterForClass(this, registerController, registerForm, classWorksheet);
activityWindow.Text = "Register for class";
activityWindow.Show();
}
else if (type == "Administrator")
{
ClassController createClassControl = new ClassController(this.db, this);
ClassList classList = new ClassList(db.GetClasses());
createClassControl.classList = classList;
CreateClassForm createClassForm = new CreateClassForm(createClassControl);
createClassControl.createClassForm = createClassForm;
CreateClass activityWindow = new CreateClass(this, createClassControl, classList, createClassForm);
activityWindow.Text = "Create class Activity Window";
activityWindow.Show();
}
else
{
ActivityWindow activityWindow = new ActivityWindow(this);
activityWindow.Text = "Avtivity Window";
activityWindow.Show();
}
}
public void Create_CreatesAnItem()
{
//Assign
TestClass test3 = _sitecore.GetItem <TestClass>("/sitecore/content/Glass/Test1/Test3");
using (new SecurityDisabler())
{
//Act
CreateClass newItem = _sitecore.Create <CreateClass, TestClass>(test3, "Test4");
//Assert
Item item = _db.GetItem("/sitecore/content/Glass/Test1/Test3/Test4");
Assert.IsNotNull(item);
Assert.AreNotEqual(item.ID, newItem.Id);
try
{
//Clean up
item.Delete();
}
catch (NullReferenceException ex)
{
//this expection is thrown by Sitecore.Tasks.ItemEventHandler.OnItemDeleted
}
}
}
public void Retval()
{
var handler = CreateClass("MyService", "MethodWithRetval")(null);
var expectedData = new byte[8];
fixed(byte *pData = expectedData)
{
*(double *)pData = 123.456;
}
service.MethodWithRetval().Returns(123.456);
var result = handler.Handle(service, null, 0).Result;
Assert.That(result, Is.EquivalentTo(expectedData));
}
public void Create_CreatesAnItem_PrePopulates()
{
//Assign
TestClass test3 = _sitecore.GetItem <TestClass>("/sitecore/content/Glass/Test1/Test3");
CreateClass preClass = new CreateClass()
{
SingleLineText = "some test data"
};
using (new SecurityDisabler())
{
//Act
CreateClass newItem = _sitecore.Create <CreateClass, TestClass>(test3, "Test5", preClass);
//Assert
Item item = _db.GetItem("/sitecore/content/Glass/Test1/Test3/Test5");
Assert.IsNotNull(item);
Assert.AreNotEqual(item.ID, newItem.Id);
Assert.AreEqual(preClass.SingleLineText, item["SingleLineText"]);
try
{
//Clean up
item.Delete();
}
catch (NullReferenceException ex)
{
//this expection is thrown by Sitecore.Tasks.ItemEventHandler.OnItemDeleted
}
}
}
public IActionResult Index()
{
CreateClass cc = new CreateClass();
cc.Init();
return(View());
}
public void GenericRetvalAsync()
{
var handler = CreateClass("MyService", "GenericRetvalAsync")(new[] { typeof(string), typeof(int) });
var pureRetval = new Dictionary <string, int> {
{ "one", 1 }, { "two", 2 }
};
service.GenericRetvalAsync <string, int>().Returns(Task.FromResult(pureRetval));
var retvalCodec = codecContainer.GetManualCodecFor <Dictionary <string, int> >();
var expectedData = retvalCodec.EncodeSingle(pureRetval);
var resultingTask = handler.Handle(service, null, 0);
Assert.That(resultingTask.Result, Is.EqualTo(expectedData));
}
private void AddCommandsToDic()
{
CreateNewFolder createNewFolder = new CreateNewFolder();
CreateNewFile createNewFile = new CreateNewFile();
LockPc lockPc = new LockPc();
Shutdown shutDown = new Shutdown();
SearchInPc searchInPc = new SearchInPc();
UnlockPc unlockPc = new UnlockPc();
SleepPc sleepPc = new SleepPc();
SleepLuna sleepLuna = new SleepLuna();
WakeUpLuna wakeUpLuna = new WakeUpLuna();
CreateClass createClass = new CreateClass();
DefineLanguage defineLanguage = new DefineLanguage();
DefineProjectName defineProjectName = new DefineProjectName();
DefineProjectPath defineProjectPath = new DefineProjectPath();
GoTo goTo = new GoTo();
WhereAmI whereAmI = new WhereAmI();
dic.Add(createNewFile.CommandName, createNewFile);
dic.Add(createNewFolder.CommandName, createNewFolder);
dic.Add(lockPc.CommandName, lockPc);
dic.Add(shutDown.CommandName, shutDown);
dic.Add(searchInPc.CommandName, searchInPc);
dic.Add(unlockPc.CommandName, unlockPc);
dic.Add(sleepPc.CommandName, sleepPc);
dic.Add(sleepLuna.CommandName, sleepLuna);
dic.Add(wakeUpLuna.CommandName, wakeUpLuna);
dic.Add(createClass.CommandName, createClass);
dic.Add(defineLanguage.CommandName, defineLanguage);
dic.Add(defineProjectName.CommandName, defineProjectName);
dic.Add(defineProjectPath.CommandName, defineProjectPath);
dic.Add(goTo.CommandName, goTo);
dic.Add(whereAmI.CommandName, whereAmI);
}
public void RetvalAsync()
{
var handler = CreateClass("MyService", "RetvalAsync")(null);
service.RetvalAsync().Returns(Task.FromResult(123456789));
var expectedData = new byte[4];
fixed(byte *pData = expectedData)
{
*(int *)pData = 123456789;
}
var resultingTask = handler.Handle(service, null, 0);
Assert.That(resultingTask.Result, Is.EqualTo(expectedData));
}
public void Out()
{
var handler = CreateClass("MyService", "GetSomethingOut")(null);
var expectedData = new byte[4];
fixed(byte *pData = expectedData)
{
*(int *)pData = 1234;
}
int dummy;
service.When(x => x.GetSomethingOut(out dummy)).Do(x => { x[0] = 1234; });
var result = handler.Handle(service, null, 0).Result;
Assert.That(result, Is.EquivalentTo(expectedData));
}
public async Task <object> Post(CreateClass request)
{
var response = new BaseResponse();
var entity = request.ConvertTo <Class>();
var result = await _classService.Create(entity);
response.Success = true;
response.StatusCode = (int)HttpStatusCode.Created;
response.Message = "Create class success";
response.Results = result;
return(response);
}
public void Arguments()
{
var handler = CreateClass("MyService", "MethodWithArgs")(null);
var data = new byte[12];
fixed(byte *pData = data)
{
*(int *)pData = 123;
*(double *)(pData + 4) = 234.567;
}
var result = handler.Handle(service, data, 0).Result;
Assert.That(result.Length, Is.EqualTo(0));
var serviceCall = service.ReceivedCalls().Single();
var arguments = serviceCall.GetArguments();
Assert.That(serviceCall.GetMethodInfo().Name, Is.EqualTo("MethodWithArgs"));
Assert.That(arguments[0], Is.EqualTo(123));
Assert.That(arguments[1], Is.EqualTo(234.567));
}
private void DoTestGenericParameters <T>(T arg)
{
var handler = CreateClass("MyService", "GenericParameters")(new[] { typeof(T) });
var argCodec = codecContainer.GetManualCodecFor <T>();
var data = new byte[argCodec.CalculateSize(arg)];
fixed(byte *pData = data)
{
var p = pData;
argCodec.Encode(ref p, arg);
}
handler.Handle(service, data, 0);
var serviceCall = service.ReceivedCalls().Last();
Assert.That(serviceCall.GetMethodInfo(), Is.EqualTo(typeof(IGlobalService).GetMethod("GenericParameters").MakeGenericMethod(new[] { typeof(T) })));
Assert.That(serviceCall.GetArguments()[0], Is.EqualTo(arg));
}
private void DoTestGenericRetval <T>(T expectedRetval)
{
var handler = CreateClass("MyService", "GenericRetval")(new[] { typeof(T) });
var retvalCodec = codecContainer.GetManualCodecFor <T>();
var expectedData = new byte[retvalCodec.CalculateSize(expectedRetval)];
fixed(byte *pData = expectedData)
{
var p = pData;
retvalCodec.Encode(ref p, expectedRetval);
}
service.GenericRetval <T>().ReturnsForAnyArgs(expectedRetval);
var result = handler.Handle(service, null, 0).Result;
var serviceCall = service.ReceivedCalls().Last();
Assert.That(serviceCall.GetMethodInfo(), Is.EqualTo(typeof(IGlobalService).GetMethod("GenericRetval").MakeGenericMethod(new[] { typeof(T) })));
Assert.That(result, Is.EquivalentTo(expectedData));
}
public static void Main(string[] args)
{
using (SqlSugarClient db = new SqlSugarClient("server=.;uid=sa;pwd=sasa;database=SqlSugarTest"))
{
var dt = db.GetDataTable("select * from student where id=@id", new { id = 1 });
//设置执行的DEMO
string switch_on = "CreateClass";
IDemos demo = null;
switch (switch_on)
{
//ADO.NET基本功能
case "Ado": demo = new Ado(); break;
//查询
case "Select": demo = new Select(); break;
//插入
case "Insert": demo = new Insert(); break;
//更新
case "Update": demo = new Update(); break;
//删除
case "Delete": demo = new Delete(); break;
//事务
case "Tran": demo = new Tran(); break;
//生成实体
case "CreateClass": demo = new CreateClass(); break;
//枚举类型的支持
case "EnumType": demo = new EnumType(); break;
//除了多库并行计算外的所有功能都已经移植成功更多例子请关注我的博客
}
//执行DEMO
demo.Init();
//更多例子请查看API
//http://www.cnblogs.com/sunkaixuan/p/5654695.html
Console.WriteLine("执行成功请关闭窗口 ,更多例子请查看API:http://www.cnblogs.com/sunkaixuan/p/5654695.html");
Console.ReadKey();
}
}
private void CreateClassStart() //食材クラスと料理クラスの生成
{
CrC = GetComponent <CreateClass>(); //同オブジェクトにアタッチされたCreateClassを取得
CrC.CreateClassStater();
CC = CrC.CC;
FS = CrC.FS;
//Debug.Log(FS[0].Name);
/*
* Debug.Log(this.CC[0].CuisineName);
* Debug.Log(this.CC.GetLength(0));
* Debug.Log(this.FS[0].Name);
* Debug.Log(this.FS[2].Name);
* Debug.Log(this.FS[7].Name);
*/
}
public IHttpActionResult Create(CreateClass model)
{
IHttpActionResult httpActionResult;
ErrorsModel errors = new ErrorsModel();
if (string.IsNullOrEmpty(model.Code))
{
errors.Add("Mã lớp là trường bắt buộc");
}
if (string.IsNullOrEmpty(model.Name))
{
errors.Add("Tên lớp là trường bắt buộc");
}
if (_db.Teachers.FirstOrDefault(m => m.Id == model.HomeroomTeacher_Id) == null)
{
errors.Add("Id giảng viên chu nhiệm không tồn tại");
}
if (errors.Errors.Count == 0)
{
Classes l = new Classes();
l.Code = model.Code;
l.Name = model.Name;
l.HomeroomTeacher = _db.Teachers.FirstOrDefault(x => x.Id == model.HomeroomTeacher_Id);
l.Teacher = _db.Teachers.FirstOrDefault(x => x.Id == model.Teacher_Id);
l = _db.Classes.Add(l);
this._db.SaveChanges();
ClassModel viewModel = new ClassModel(l);
httpActionResult = Ok(viewModel);
}
else
{
httpActionResult = new ErrorActionResult(Request, System.Net.HttpStatusCode.BadRequest, errors);
}
return(httpActionResult);
}
public NamespaceComposer AddClass(ClassOptions options)
{
if (!IsAtRoot())
{
throw new Exception("The namespace must be selected (which is root to the composer) to add a class to it.");
}
var template = new CreateClass()
{
Options = options
};
var code = template.TransformText();
var cu = SyntaxFactory.ParseCompilationUnit(code).NormalizeWhitespace();
var newClass = cu.DescendantNodes().OfType <ClassDeclarationSyntax>().First();
var @namespace = CurrentNode as NamespaceDeclarationSyntax;
@namespace = @namespace.AddMembers(newClass);
Replace(CurrentNode, @namespace, null);
return(this);
}
public void ToolMouseUp(object sender, MouseEventArgs e)
{
if (rectangle != null)
{
if (e.Button == MouseButtons.Left)
{
List <Vertex> newVertexs = new List <Vertex>();
newVertexs.Add(rectangle);
ICommand command = new CreateClass(newVertexs, canvas);
canvas.AddCommand(command);
canvas.DeselectAllObjects();
this.rectangle.Select();
canvas.SetSelectedObject(this.rectangle);
canvas.GetListSelectedObject().Add(this.rectangle);
}
/*else if (e.Button == MouseButtons.Right)
* {
* canvas.RemoveDrawingObject(this.rectangle);
* canvas.RemoveDrawingObject(this.rectangle);
* canvas.RemoveDrawingObject(this.rectangle);
* }*/
}
}
public async Task <int?> AddClass(CreateClass clazz)
{
var classJson = JsonConvert.SerializeObject(clazz);
using (var _client = HttpClientHelper.GetAuthenticatedHttpClient())
{
var content = new StringContent(classJson, Encoding.UTF8, "application/json");
var result = await _client.PostAsync(CREATE_CLASS, content);
if (result.IsSuccessStatusCode)
{
var responseText = await result.Content.ReadAsStringAsync();
var res = JsonConvert.DeserializeObject <ClassCreatedResponse>(responseText);
return(res.ClassId);
}
else
{
return(null);
}
}
}
public void Create_CreatesAnItem_PrePopulates_NewMethod()
{
//Assign
TestClass test3 = _sitecore.GetItem<TestClass>("/sitecore/content/Glass/Test1/Test3");
CreateClass preClass = new CreateClass() { SingleLineText = "some test data", Name = "Test6" };
using (new SecurityDisabler())
{
//Act
CreateClass newItem = _sitecore.Create<CreateClass, TestClass>(test3, preClass);
//Assert
Item item = _db.GetItem("/sitecore/content/Glass/Test1/Test3/Test6");
Assert.AreEqual(preClass, newItem);
Assert.AreEqual(item.ID.Guid, newItem.Id);
Assert.IsNotNull(item);
Assert.AreNotEqual(item.ID, newItem.Id);
Assert.AreEqual(preClass.SingleLineText, item["SingleLineText"]);
try
{
//Clean up
item.Delete();
}
catch (NullReferenceException ex)
{
//this expection is thrown by Sitecore.Tasks.ItemEventHandler.OnItemDeleted
}
}
}
/// <summary>
/// <para>
/// Adds a create class category for the container. Create classes give indication
/// of what types of items can be created as descendents or children of a container.
/// </para>
///
/// <para>
/// TODO: Should implement something that actually employs CreateClasses in the device-side implementation
/// of CDS.
/// </para>
/// </summary>
/// <param name="cc"></param>
internal void RemoveCreateClass (CreateClass cc)
{
this.m_Properties.RemoveVal (T[_UPNP.createClass], cc);
}
/// <summary>
/// <para>
/// Adds a create class category for the container. Create classes give indication
/// of what types of items can be created as descendents or children of a container.
/// </para>
///
/// <para>
/// TODO: Should implement something that actually employs CreateClasses in the device-side implementation
/// of CDS.
/// </para>
/// </summary>
/// <param name="cc"></param>
internal void AddCreateClass (CreateClass cc)
{
this.m_Properties.AddVal(T[_UPNP.createClass], cc);
}
