public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
// Execute code directly.
case "Code":
lua.DoString(parameter.GetValue<string>());
break;
// Open the .lua file in SS14.Server\Scripts\
case "File":
string fileName = Path.Combine("Scripts", parameter.GetValue<string>());
string fileContents = "";
if (scriptCache.ContainsKey(fileName))
{
// Console.WriteLine("Getting {0} from ScriptCache", fileName);
fileContents = scriptCache[fileName];
}
else
{
if (!File.Exists(fileName))
throw new FileNotFoundException("Unable to find Lua script file!", fileName);
fileContents = File.ReadAllText(fileName);
scriptCache.Add(fileName, fileContents);
}
lua.DoString(fileContents);
break;
}
}
public override void SetParameter(ComponentParameter parameter)
{
switch (parameter.MemberName)
{
case "lightoffsetx":
_lightOffset.X = parameter.GetValue<float>();
//float.Parse((string)parameter.Parameter, System.Globalization.CultureInfo.InvariantCulture);
break;
case "lightoffsety":
_lightOffset.Y = parameter.GetValue<float>();
//float.Parse((string)parameter.Parameter, System.Globalization.CultureInfo.InvariantCulture);
break;
case "lightradius":
_lightRadius = parameter.GetValue<int>(); //int.Parse((string) parameter.Parameter);
break;
case "lightColorR":
_lightColor.X = parameter.GetValue<int>(); //int.Parse((string) parameter.Parameter);
break;
case "lightColorG":
_lightColor.Y = parameter.GetValue<int>(); //int.Parse((string)parameter.Parameter);
break;
case "lightColorB":
_lightColor.Z = parameter.GetValue<int>(); //int.Parse((string)parameter.Parameter);
break;
case "mask":
_mask = parameter.GetValue<string>(); // parameter.Parameter;
break;
}
}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "OpenSprite":
openSprite = parameter.GetValue<string>();
break;
case "ClosedSprite":
closedSprite = parameter.GetValue<string>();
break;
case "OpenOnBump":
openonbump = parameter.GetValue<bool>();
break;
case "AutoCloseInterval":
var autocloseinterval = parameter.GetValue<int>();
if (autocloseinterval == 0)
autoclose = false;
else
{
autoclose = true;
openLength = autocloseinterval;
}
break;
default:
base.SetParameter(parameter);
break;
}
}
/// <summary>
/// Set parameters :)
/// </summary>
/// <param name="parameter"></param>
public override void SetParameter(ComponentParameter parameter)
{
var tileSize = IoCManager.Resolve<IMapManager>().TileSize;
//base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "SizeX":
var width = parameter.GetValue<float>() / tileSize;
AABB = new FloatRect(AABB.Left + (AABB.Width - width) / 2f, AABB.Top, width, AABB.Height);
break;
case "SizeY":
var height = parameter.GetValue<float>() / tileSize;
AABB = new FloatRect(AABB.Left, AABB.Top + (AABB.Height - height) / 2f, AABB.Width, height);
break;
case "OffsetX":
var x = parameter.GetValue<float>() / tileSize;
AABB = new FloatRect(x - AABB.Width / 2f, AABB.Top, AABB.Width, AABB.Height);
break;
case "OffsetY":
var y = parameter.GetValue<float>() / tileSize;
AABB = new FloatRect(AABB.Left, y - AABB.Height / 2f, AABB.Width, AABB.Height);
break;
}
}
public override void SetParameter(ComponentParameter parameter)
{
switch (parameter.MemberName) {
case "DebugColor":
DebugColor = ColorUtils.FromHex(parameter.GetValue<string>(), Color.Blue);
break;
}
}
public override void SetParameter(ComponentParameter parameter) {
switch (parameter.MemberName) {
case "DebugColor":
var color = ColorTranslator.FromHtml(parameter.GetValue<string>());
if (!color.IsEmpty)
DebugColor = color;
break;
}
}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "TweakAABB":
TweakAABB = parameter.GetValue<Vector4D>();
break;
}
}
//private void GasEffect()
//{
// ITile t = IoCManager.Resolve<IMapManager>().GetFloorAt(Owner.GetComponent<TransformComponent>(ComponentFamily.Transform).Position);
// if (t == null)
// return;
// Vector2 gasVel = t.GasCell.GasVelocity;
// if (gasVel.Abs() > Mass) // Stop tiny wobbles
// {
// Owner.SendMessage(this, ComponentMessageType.PhysicsMove,
// Owner.GetComponent<TransformComponent>(ComponentFamily.Transform).Position.X +
// gasVel.X,
// Owner.GetComponent<TransformComponent>(ComponentFamily.Transform).Position.Y +
// gasVel.Y);
// }
//}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "Mass":
Mass = parameter.GetValue<float>();
break;
}
}
/// <summary>
/// Set parameters :)
/// </summary>
/// <param name="parameter"></param>
public override void SetParameter(ComponentParameter parameter)
{
//base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "icon":
var iconName = parameter.GetValue<string>();
SetIcon(iconName);
break;
}
}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "wearloc":
wearloc = (EquipmentSlot) Enum.Parse(typeof (EquipmentSlot), parameter.GetValue<string>());
break;
}
}
public override void SetParameter(ComponentParameter parameter)
{
switch (parameter.MemberName)
{
case "playersession": //TODO this shouldnt be a parameter.
playerSession = parameter.GetValue<IPlayerSession>();
break;
default:
base.SetParameter(parameter);
break;
}
}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "notWornSprite":
SetNotWornSprite(parameter.GetValue<string>());
break;
case "carriedSprite":
SetCarriedSprite(parameter.GetValue<string>());
break;
}
}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "drawdepth":
DrawDepth = (DrawDepth)Enum.Parse(typeof(DrawDepth), parameter.GetValue<string>(), true);
break;
case "sprite":
Name = parameter.GetValue<string>();
break;
}
}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "LoadThinkComponent":
IThinkComponent c = GetThinkComponent(parameter.GetValue<string>());
if (c == null)
break;
ThinkComponents.Add(c);
break;
}
}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "drawdepth":
SetDrawDepth((DrawDepth)Enum.Parse(typeof(DrawDepth), parameter.GetValue <string>(), true));
break;
case "sprite":
baseSprite = parameter.GetValue <string>();
SetSprite(parameter.GetValue <string>());
break;
}
}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "AddEffect":
AddEffect(parameter.GetValue <string>(), 10);
break;
default:
base.SetParameter(parameter);
break;
}
}
public void Should_DisplayCountry_When_IdIsPresent()
{
//Arrange
var country = _fixture.Create <CountryModel>();
_countryService.Setup(service => service.Get(It.IsAny <string>())).Returns(Task.FromResult(country));
var countryDetail = RenderComponent <CountryDetail>(ComponentParameter.CreateParameter("Id", 1));
// Act
var title = countryDetail.Find("h2");
// Assert
title.MarkupMatches($"<h2><span>Country</span>{country.Id}</h2>");
}
public void Renders_Label_ForPropertyWithDisplayAttributeAndAdditionalAttributes()
{
// Arrange
Expression <Func <string> > For = () => _model.First;
var parameters = new[] { ComponentParameter.CreateParameter("For", For), ComponentParameter.CreateParameter("class", "c") };
// Act
var component = RenderComponent <LabelText <string> >(parameters);
// Assert
Assert.Equal("<label class=\"c\">my_value</label>", component.Find("label").OuterHtml);
// Verify
_stringLocalizerMock.Verify(localizer => localizer["Person_First"], Times.Once);
}
public void Open_FixMonth_ClickYear_Click3_CheckDate()
{
var comp = OpenPicker(ComponentParameter.CreateParameter("FixMonth", 1));
comp.FindAll("div.mud-picker-calendar-container > .mud-picker-calendar-header > .mud-picker-calendar-header-switch > .mud-button-month").Count().Should().Be(0);
comp.Find("div.mud-picker-datepicker-toolbar > button.mud-button-year").Click();
comp.FindAll("div.mud-picker-calendar-container > div.mud-picker-year-container").Count.Should().Be(1);
comp.FindAll("div.mud-picker-calendar-container > div.mud-picker-year-container > div.mud-picker-year")
.Where(x => x.TrimmedText().Contains("2022")).First().Click();
comp.FindAll("div.mud-picker-month-container").Count.Should().Be(0);
comp.FindAll("div.mud-picker-calendar-container > div.mud-picker-calendar-header").Count.Should().Be(1);
comp.FindAll("button.mud-picker-calendar-day")
.Where(x => x.TrimmedText().Equals("3")).First().Click();
comp.Instance.Date.Value.Date.Should().Be(new DateTime(2022, 1, 3));
}
public static WebAssemblyComponentMarker SerializeInvocation(Type type, ParameterView parameters, bool prerendered)
{
var assembly = type.Assembly.GetName().Name;
var typeFullName = type.FullName;
var(definitions, values) = ComponentParameter.FromParameterView(parameters);
// We need to serialize and Base64 encode parameters separately since they can contain arbitrary data that might
// cause the HTML comment to be invalid (like if you serialize a string that contains two consecutive dashes "--").
var serializedDefinitions = Convert.ToBase64String(JsonSerializer.SerializeToUtf8Bytes(definitions, WebAssemblyComponentSerializationSettings.JsonSerializationOptions));
var serializedValues = Convert.ToBase64String(JsonSerializer.SerializeToUtf8Bytes(values, WebAssemblyComponentSerializationSettings.JsonSerializationOptions));
return(prerendered ? WebAssemblyComponentMarker.Prerendered(assembly, typeFullName, serializedDefinitions, serializedValues) :
WebAssemblyComponentMarker.NonPrerendered(assembly, typeFullName, serializedDefinitions, serializedValues));
}
public void Should_DisplayUserLogin_When_IdIsPresent()
{
//Arrange
var user = _fixture.Create <UserModel>();
_userService.Setup(service => service.Get(It.IsAny <string>())).Returns(Task.FromResult(user));
var userDetail = RenderComponent <UserDetail>(ComponentParameter.CreateParameter("Id", "test"));
// Act
var title = userDetail.Find("h2");
// Assert
title.MarkupMatches($"<h2><span>User</span> [<b>{user.Login}</b>]</h2>");
}
public void Timeline_Title_ShouldRenderWithTitle()
{
// Arrange
const string expectedTitle = "Test Title";
// Act
var timeline = _context.RenderComponent <Timeline>(
ComponentParameter.CreateParameter(nameof(Timeline.Title), expectedTitle)
);
// Assert
var container = timeline.Find("div");
var projectTitle = container.GetElementsByTagName("h1");
projectTitle.Should().HaveCount(1);
projectTitle[0].Text().Should().Be(expectedTitle);
}
private void PreparePlacement(string templateName)
{
var prototype = _prototypeManager.Index <EntityPrototype>(templateName);
ComponentParameter spriteParam = prototype.GetBaseSpriteParameters().FirstOrDefault();
//Will break if states not ordered correctly.
var spriteName = spriteParam == null ? "" : spriteParam.GetValue <string>();
Sprite sprite = ResourceCache.GetSprite(spriteName);
CurrentBaseSprite = sprite;
CurrentBaseSpriteKey = spriteName;
CurrentPrototype = prototype;
IsActive = true;
}
public async Task NumericFieldUpdateLoopProtectionTest()
{
var comp = ctx.RenderComponent <MudNumericField <int> >();
// these conversion funcs are nonsense of course, but they are designed this way to
// test against an infinite update loop that numericFields and other inputs are now protected against.
var numericField = comp.Instance;
numericField.Converter.SetFunc = s => s.ToString();
numericField.Converter.GetFunc = s => int.Parse(s);
comp.SetParametersAndRender(ComponentParameter.CreateParameter("Value", 1));
numericField.Value.Should().Be(1);
numericField.Text.Should().Be("1");
comp.Find("input").Change("3");
numericField.Value.Should().Be(3);
numericField.Text.Should().Be("3");
}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "LoadThinkComponent":
IThinkComponent c = GetThinkComponent(parameter.GetValue <string>());
if (c == null)
{
break;
}
ThinkComponents.Add(c);
break;
}
}
public void CheckBoxTest2()
{
var comp = Context.RenderComponent <MudCheckBox <bool> >(ComponentParameter.CreateParameter("Checked", true));
//Console.WriteLine(comp.Markup);
// select elements needed for the test
var box = comp.Instance;
var input = comp.Find("input");
// check initial state
box.Checked.Should().Be(true);
// click and check if it has toggled
input.Change(false);
box.Checked.Should().Be(false);
input.Change(true);
box.Checked.Should().Be(true);
}
public async Task TextFieldWithNullableTypes()
{
var comp = ctx.RenderComponent <MudTextField <int?> >(ComponentParameter.CreateParameter("Value", 17));
// print the generated html
Console.WriteLine(comp.Markup);
var textfield = comp.Instance;
await comp.InvokeAsync(() => textfield.Value = null);
comp.Find("input").Blur();
comp.FindAll("div.mud-input-error").Count.Should().Be(0);
await comp.InvokeAsync(() => textfield.Text = "");
comp.Find("input").Blur();
comp.FindAll("div.mud-input-error").Count.Should().Be(0);
}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "MaxHealth":
maxHealth = parameter.GetValue <int>();
currentHealth = maxHealth;
break;
case "CurrentHealth":
currentHealth = parameter.GetValue <int>();
break;
}
}
public async Task TextFieldUpdateLoopProtectionTest()
{
var comp = Context.RenderComponent <MudTextField <string> >();
// these conversion funcs are nonsense of course, but they are designed this way to
// test against an infinite update loop that textfields and other inputs are now protected against.
var textfield = comp.Instance;
textfield.Converter.SetFunc = s => $"{s}x";
textfield.Converter.GetFunc = s => $"{s}y";
comp.SetParametersAndRender(ComponentParameter.CreateParameter("Value", "A"));
textfield.Value.Should().Be("A");
textfield.Text.Should().Be("Ax");
comp.Find("input").Change("B");
textfield.Value.Should().Be("By");
textfield.Text.Should().Be("B");
}
public void Numeric_Formatted()
{
using var ctx = new TestContext();
double valueToTest = 100.234;
string format = "0.00";
var component = ctx.RenderComponent <RadzenNumeric <double> >(
ComponentParameter.CreateParameter(nameof(RadzenNumeric <double> .Format), format),
ComponentParameter.CreateParameter(nameof(RadzenNumeric <double> .Value), valueToTest)
);
component.Render();
Assert.Contains($" value=\"{valueToTest.ToString(format)}\"", component.Markup);
}
public IComponentBuilder <TComponent> RenderFragment <T>(
Expression <Func <TComponent, RenderFragment <T> > > expression,
Action <IComponentBuilder <T> > builderCallback
)
where T : class, IComponent
{
var propertyName = GetPropertyName(expression);
var builder = new ComponentBuilder <T>();
builderCallback(builder);
_componentParameters.Add(
ComponentParameter.CreateParameter(
propertyName,
builder.ToRenderFragment()
)
);
return(this);
}
public async Task TextFieldWithNullableTypes()
{
using var ctx = new Bunit.TestContext();
//ctx.Services.AddSingleton<NavigationManager>(new MockNavigationManager());
var comp = ctx.RenderComponent <MudTextField <int?> >(ComponentParameter.CreateParameter("Value", 17));
// print the generated html
Console.WriteLine(comp.Markup);
var textfield = comp.Instance;
await comp.InvokeAsync(() => textfield.Value = null);
comp.Find("input").Blur();
comp.FindAll("div.mud-input-error").Count.Should().Be(0);
await comp.InvokeAsync(() => textfield.Text = "");
comp.Find("input").Blur();
comp.FindAll("div.mud-input-error").Count.Should().Be(0);
}
private void InitializeHttpCallNewItem(ComponentParameter userIdParameter)
{
int userId = (int)userIdParameter.Value;
MockHttp.Expect(HttpMethod.Get, $"http://localhost/User/GetUser/{userId}")
.RespondValues(new UserObject {
Id = userId == ThisUser.Id ? ThisUserDatabaseId : userId, UserName = "******"
});
MockHttp.Expect(HttpMethod.Get, "http://localhost/StarpointsManager/GetStarpointsType/-1")
.RespondValues(new[] { new StarpointsType {
Id = 1
} });
if (userId != ThisUser.Id)
{
MockHttp.Expect(HttpMethod.Get, $"http://localhost/User/GetUserStartechs/{userId}")
.RespondValues(new[] { Startechs.Dotnet });
}
}
public async Task when_suppressing_item_if_the_pop_up_retrieve_no_the_item_should_not_be_suppressed()
{
ConfirmDisplayer.Setup(x => x.Confirm(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.Factory.StartNew(() => false));
bool hasCallRemoveCallback = false;
var removeItemEventCallBack = EventCallbackFactory.Create <StarpointsItem>(new object(), _ => hasCallRemoveCallback = true);
var starpointsItem = CreateStarpointsItem();
Authorize(starpointsItem, false);
var component = CreateComponent(ComponentParameter.CreateParameter("Item", starpointsItem)
, ComponentParameter.CreateParameter("PleaseRemoveItem", removeItemEventCallBack));
component.WaitForState(() => component.Nodes?.Length > 0);
await component.Instance.CancelItem();
await Task.Delay(30);
hasCallRemoveCallback.Should().BeFalse();
}
public async Task when_updating_status_the_update_status_api_method_should_be_called()
{
ConfirmDisplayer.Setup(x => x.Confirm(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.Factory.StartNew(() => true));
var removeItemEventCallBack = EventCallbackFactory.Create <StarpointsItem>(new object(), _ => { });
var starpointsItem = CreateStarpointsItem();
MockHttp.Expect($"http://localhost/StarpointsManager/CancelStarpoints/-1/{starpointsItem.Id}").Respond(HttpStatusCode.OK);
Authorize(starpointsItem, false);
var component = CreateComponent(ComponentParameter.CreateParameter("Item", starpointsItem)
, ComponentParameter.CreateParameter("PleaseRemoveItem", removeItemEventCallBack));
component.WaitForState(() => component.Nodes?.Length > 0);
await component.Instance.CancelItem();
await Task.Delay(30);
MockHttp.VerifyNoOutstandingExpectation();
}
public async Task FormValidationTest1()
{
var validationFunc = new Func <string, bool>(x => x?.StartsWith("Marilyn") == true);
var comp = ctx.RenderComponent <FormValidationTest>(ComponentParameter.CreateParameter("validation", validationFunc));
Console.WriteLine(comp.Markup);
var form = comp.FindComponent <MudForm>().Instance;
var textFieldcomp = comp.FindComponent <MudTextField <string> >();
var textField = textFieldcomp.Instance;
// check initial state: form should not be valid, but text field does not display an error initially!
form.IsValid.Should().Be(false);
textField.Error.Should().BeFalse();
textField.ErrorText.Should().BeNullOrEmpty();
// this rock star starts with Marilyn
textFieldcomp.Find("input").Change("Marilyn Manson");
form.IsValid.Should().Be(true);
form.Errors.Length.Should().Be(0);
textField.Error.Should().BeFalse();
textField.ErrorText.Should().BeNullOrEmpty();
// this rock star doesn't start with Marilyn
textFieldcomp.Find("input").Change("Kurt Cobain");
form.IsValid.Should().Be(false);
form.Errors.Length.Should().Be(1);
textField.Error.Should().BeTrue();
textField.ErrorText.Should().Be("Invalid");
// note: this logic is invalid, so it was removed. Validaton funcs are always called
// the validation func must validate non-required empty fields as valid.
//
//// value is not required, so don't call the validation func on empty text
//await comp.InvokeAsync(() => textField.Value = "");
//form.IsValid.Should().Be(true);
//form.Errors.Length.Should().Be(0);
//textField.Error.Should().BeFalse();
//textField.ErrorText.Should().BeNullOrEmpty();
// ok, not a rock star, but a star nonetheless
textFieldcomp.Find("input").Change("Marilyn Monroe");
form.IsValid.Should().Be(true);
form.Errors.Length.Should().Be(0);
textField.Error.Should().BeFalse();
textField.ErrorText.Should().BeNullOrEmpty();
}
public override void SetParameter(ComponentParameter parameter)
{
switch (parameter.MemberName)
{
case "damageAmount":
damageAmount = parameter.GetValue <int>();
break;
case "damageType":
if (parameter.ParameterType == typeof(string))
{
//Try to parse it. Set to Bludgeoning damagetype if parsing fails
if (!Enum.TryParse(parameter.GetValue <string>(), true, out damType))
{
damType = DamageType.Bludgeoning;
}
}
else if (parameter.ParameterType == typeof(DamageType))
{
damType = parameter.GetValue <DamageType>();
}
break;
case "startActive":
active = parameter.GetValue <bool>();
break;
case "toggleable":
toggleable = parameter.GetValue <bool>();
if (!toggleable)
{
active = true;
}
break;
case "inactiveSprite":
inactiveSprite = parameter.GetValue <string>();
break;
case "activeSprite":
activeSprite = parameter.GetValue <string>();
break;
}
}
protected IRenderedComponent <TComnponent> CreateComponent(string userName,
string role,
string?id)
{
Factory.ConfigureTestContext(userName,
new Claim[]
{
new Claim("scope", SharedConstants.ADMINSCOPE),
new Claim("role", SharedConstants.READERPOLICY),
new Claim("role", role),
new Claim("sub", Guid.NewGuid().ToString())
},
this);
var component = RenderComponent <TComnponent>(ComponentParameter.CreateParameter("Id", id));
component.WaitForState(() => !component.Markup.Contains("Loading..."), TimeSpan.FromMinutes(1));
return(component);
}
public async Task TextField_Data_Annotation_Resolve_Name_Of_Field()
{
var model = new TestDataAnnotationModel();
var comp = Context.RenderComponent <MudTextField <string> >(ComponentParameter.CreateParameter("For", (Expression <Func <string> >)(() => model.Foo1)));
await comp.InvokeAsync(() => comp.Instance.Validate());
comp.Instance.Error.Should().BeTrue();
comp.Instance.ValidationErrors.Should().HaveCount(1);
comp.Instance.ValidationErrors[0].Should().Be($"The {nameof(TestDataAnnotationModel.Foo1)} field is required.");
comp.Instance.GetErrorText().Should().Be($"The {nameof(TestDataAnnotationModel.Foo1)} field is required.");
await comp.InvokeAsync(() =>
{
comp.Instance.Value = "Foo";
comp.Instance.Validate();
});
comp.Instance.Error.Should().BeFalse();
comp.Instance.ValidationErrors.Should().HaveCount(0);
}
public async Task when_suppressing_item_if_the_pop_up_retrieve_yes_the_item_should_be_suppressed()
{
ConfirmDisplayer.Setup(x => x.Confirm(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.Factory.StartNew(() => true));
bool hasCallRemoveCallback = false;
var removeItemEventCallBack = EventCallbackFactory.Create <StarpointsItem>(new object(), _ => hasCallRemoveCallback = true);
var starpointsItem = CreateStarpointsItem();
MockHttp.Expect($"http://localhost/StarpointsManager/CancelStarpoints/-1/{starpointsItem.Id}").Respond(HttpStatusCode.OK);
Authorize(starpointsItem, false);
var component = CreateComponent(ComponentParameter.CreateParameter("Item", starpointsItem)
, ComponentParameter.CreateParameter("PleaseRemoveItem", removeItemEventCallBack));
component.WaitForState(() => component.Nodes?.Length > 0);
await component.Instance.CancelItem();
await Task.Delay(30);
hasCallRemoveCallback.Should().BeTrue();
}
public void CheckBoxTest2()
{
using var ctx = new Bunit.TestContext();
var comp = ctx.RenderComponent <MudCheckBox <bool> >(new [] { ComponentParameter.CreateParameter("Checked", true), });
// print the generated html
Console.WriteLine(comp.Markup);
// select elements needed for the test
var box = comp.Instance;
var input = comp.Find("input");
// check initial state
box.Checked.Should().Be(true);
// click and check if it has toggled
input.Change(false);
box.Checked.Should().Be(false);
input.Change(true);
box.Checked.Should().Be(true);
}
public async Task FormValidationTest1()
{
using var ctx = new Bunit.TestContext();
var validationFunc = new Func <string, Task <bool> >(async x => x?.StartsWith("Marilyn") == true);
var comp = ctx.RenderComponent <FormValidationTest>(ComponentParameter.CreateParameter("validation", validationFunc));
Console.WriteLine(comp.Markup);
var form = comp.FindComponent <MudForm>().Instance;
var textField = comp.FindComponent <MudTextField <string> >().Instance;
// check initial state: form should not be valid, but text field does not display an error initially!
form.IsValid.Should().Be(false);
textField.Error.Should().BeFalse();
textField.ErrorText.Should().BeNullOrEmpty();
await comp.InvokeAsync(() => textField.Value = "Marilyn Manson");
form.IsValid.Should().Be(true);
form.Errors.Length.Should().Be(0);
textField.Error.Should().BeFalse();
textField.ErrorText.Should().BeNullOrEmpty();
// this rock star doesn't start with Marilyn
await comp.InvokeAsync(() => textField.Value = "Kurt Cobain");
form.IsValid.Should().Be(false);
form.Errors.Length.Should().Be(1);
textField.Error.Should().BeTrue();
textField.ErrorText.Should().Be("Invalid");
// value is not required, so don't call the validation func on empty text
await comp.InvokeAsync(() => textField.Value = "");
form.IsValid.Should().Be(true);
form.Errors.Length.Should().Be(0);
textField.Error.Should().BeFalse();
textField.ErrorText.Should().BeNullOrEmpty();
// ok, not a rock star, but a star nonetheless
await comp.InvokeAsync(() => textField.Value = "Marilyn Monroe");
form.IsValid.Should().Be(true);
form.Errors.Length.Should().Be(0);
textField.Error.Should().BeFalse();
textField.ErrorText.Should().BeNullOrEmpty();
}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "startState":
_state = (LightState) Enum.Parse(typeof (LightState), parameter.GetValue<string>(), true);
break;
case "lightColorR":
_colorR = int.Parse(parameter.GetValue<string>());
break;
case "lightColorG":
_colorG = int.Parse(parameter.GetValue<string>());
break;
case "lightColorB":
_colorB = int.Parse(parameter.GetValue<string>());
break;
}
}
/// <summary>
/// Set parameters :)
/// </summary>
/// <param name="parameter"></param>
public override void SetParameter(ComponentParameter parameter)
{
//base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "drawdepth":
SetDrawDepth((DrawDepth)Enum.Parse(typeof(DrawDepth), parameter.GetValue <string>(), true));
break;
case "basename":
basename = parameter.GetValue <string>();
LoadSprites();
break;
case "addsprite":
var spriteToAdd = parameter.GetValue <string>();
LoadSprites(spriteToAdd);
break;
}
}
public async Task ChipSet_MultiSelection_DefaultChipsShouldBeInitiallySelected()
{
var comp = Context.RenderComponent <ChipSetDefaultChipsTest>(ComponentParameter.CreateParameter("MultiSelection", true));
// print the generated html
//Console.WriteLine(comp.Markup);
// select elements needed for the test
var chipset = comp.FindComponent <MudChipSet>();
comp.FindAll("div.mud-chip").Count.Should().Be(7);
chipset.Instance.SelectedChips.Length.Should().Be(2);
comp.FindAll("p")[0].TrimmedText().Should().Be("Eggs, Salad");
// select cornflakes
comp.FindAll("div.mud-chip")[3].Click();
comp.FindAll("p")[0].TrimmedText().Should().Be("Corn flakes, Eggs, Salad");
string.Join(", ", chipset.Instance.SelectedChips.Select(x => x.Text).OrderBy(x => x)).Should().Be("Corn flakes, Eggs, Salad");
// de-select eggs
comp.FindAll("div.mud-chip")[1].Click();
comp.FindAll("p")[0].TrimmedText().Should().Be("Corn flakes, Salad");
string.Join(", ", chipset.Instance.SelectedChips.Select(x => x.Text).OrderBy(x => x)).Should().Be("Corn flakes, Salad");
}
/// <summary>
/// Set parameters :)
/// </summary>
/// <param name="parameter"></param>
public override void SetParameter(ComponentParameter parameter)
{
//base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "drawdepth":
SetDrawDepth((DrawDepth) Enum.Parse(typeof (DrawDepth), parameter.GetValue<string>(), true));
break;
case "basename":
_basename = parameter.GetValue<string>();
LoadSprites();
break;
}
}
public override void SetParameter(ComponentParameter parameter)
{
switch (parameter.MemberName)
{
case "healAmount":
healAmount = parameter.GetValue<int>();
break;
case "damageType":
if (parameter.ParameterType == typeof (string))
{
//Try to parse it. Set to Bludgeoning damagetype if parsing fails
if (!Enum.TryParse(parameter.GetValue<string>(), true, out damType))
damType = DamageType.Bludgeoning;
}
else if (parameter.ParameterType == typeof (DamageType))
{
damType = parameter.GetValue<DamageType>();
}
break;
case "capacity":
capacity = parameter.GetValue<int>();
break;
}
}
public override void HandleExtendedParameters(XElement extendedParameters)
{
foreach (XElement itemcapability in extendedParameters.Descendants("ItemCapability"))
{
IEnumerable<XElement> Verbs = itemcapability.Descendants("ItemCapabilityVerb");
IEnumerable<XElement> Parameters = itemcapability.Descendants("ItemCapabilityParameter");
ItemCapability cap = null;
switch (itemcapability.Attribute("name").Value)
{
case "MeleeWeaponCapability":
cap = new MeleeWeaponCapability();
break;
case "ToolCapability":
cap = new ToolCapability();
break;
case "GunCapability":
cap = new GunCapability();
break;
case "MedicalCapability":
cap = new MedicalCapability();
break;
case "HealthScanCapability":
cap = new HealthScanCapability();
break;
case "BreatherCapability":
cap = new BreatherCapability();
break;
}
if (cap == null)
return;
foreach (XElement verb in Verbs)
{
cap.AddVerb(int.Parse(verb.Attribute("priority").Value),
(ItemCapabilityVerb)
Enum.Parse(typeof (ItemCapabilityVerb), verb.Attribute("name").Value));
}
foreach (XElement parameter in Parameters)
{
string name = parameter.Attribute("name").Value;
Type type = EntityTemplate.TranslateType(parameter.Attribute("type").Value);
object value = Convert.ChangeType(parameter.Attribute("value").Value, type);
var cparam = new ComponentParameter(name, value);
cap.SetParameter(cparam);
}
AddCapability(cap);
}
}
/// <summary>
/// Sets a parameter for a component type for this template
/// </summary>
/// <param name="componentType">The type of the component to set a parameter on</param>
/// <param name="parameter">The parameter object</param>
public void SetParameter(string componentType, ComponentParameter parameter)
{
if (_parameters.ContainsKey(componentType))
_parameters[componentType].Add(parameter);
}
/// <summary>
/// Parameter Setting
/// Settable params:
/// TweakAABB - Vector4D
/// </summary>
/// <param name="parameter"></param>
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "TweakAABB":
TweakAABB = parameter.GetValue<Vector4D>();
break;
case "TweakAABBtop":
tweakAABB.X = parameter.GetValue<float>();
break;
case "TweakAABBright":
tweakAABB.Y = parameter.GetValue<float>();
break;
case "TweakAABBbottom":
tweakAABB.Z = parameter.GetValue<float>();
break;
case "TweakAABBleft":
tweakAABB.W = parameter.GetValue<float>();
break;
}
}
/// <summary>
/// Parameter Setting
/// Settable params:
/// TweakAABB - Vector4
/// </summary>
/// <param name="parameter"></param>
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "TweakAABB":
TweakAABB = parameter.GetValue<Vector4f>() / IoCManager.Resolve<IMapManager>().TileSize;
break;
case "TweakAABBtop":
tweakAABB.X = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize;
break;
case "TweakAABBright":
tweakAABB.Y = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize;
break;
case "TweakAABBbottom":
tweakAABB.Z = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize;
break;
case "TweakAABBleft":
tweakAABB.W = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize;
break;
case "DebugColor":
DebugColor = ColorUtils.FromHex(parameter.GetValue<string>(), Color.Red);
break;
}
}
public MarshalComponentParameter(ComponentFamily family, ComponentParameter parameter)
{
Family = family;
Parameter = parameter;
}
public void LoadFromXml(XElement templateElement)
{
Name = templateElement.Attribute("name").Value;
IEnumerable<XElement> tComponents = templateElement.Element("Components").Elements();
//Parse components
foreach (XElement tComponent in tComponents)
{
string componentname = tComponent.Attribute("name").Value;
_components.Add(componentname);
_parameters.Add(componentname, new List<ComponentParameter>());
IEnumerable<XElement> tComponentParameters = from tParam in tComponent.Descendants("Parameter")
select tParam;
//Parse component parameters
foreach (XElement tComponentParameter in tComponentParameters)
{
if (tComponentParameter.Attribute("type").Value == "" ||
tComponentParameter.Attribute("name").Value == "")
throw new ArgumentException("Component Parameter name or type not set.");
//Get the specified type
Type paramType = TranslateType(tComponentParameter.Attribute("type").Value);
//Get the raw value
string paramRawValue = tComponentParameter.Attribute("value").Value;
//Validate
string paramName = tComponentParameter.Attribute("name").Value;
if (paramType == null)
throw new TemplateLoadException("Invalid parameter type specified.");
if (paramName == "")
throw new TemplateLoadException("Invalid parameter name specified.");
//Convert the raw value to the proper type
object paramValue; // = Convert.ChangeType(tComponentParameter.Attribute("value").Value, paramType);
if (paramType == typeof (int))
{
int pval;
if (!int.TryParse(paramRawValue, out pval))
throw new ArgumentException("Could not parse parameter " + paramName + " as int. Value: " +
paramRawValue);
paramValue = pval;
}
else if (paramType == typeof (float))
{
float pval;
if (!float.TryParse(paramRawValue, NumberStyles.Float, CultureInfo.InvariantCulture, out pval))
throw new ArgumentException("Could not parse parameter " + paramName + " as float. Value: " +
paramRawValue);
paramValue = pval;
}
else if (paramType == typeof (bool))
{
bool pval;
if (!bool.TryParse(paramRawValue, out pval))
throw new ArgumentException("Could not parse parameter " + paramName + " as bool. Value: " +
paramRawValue);
paramValue = pval;
}
else if (paramType == typeof (string))
{
paramValue = paramRawValue;
}
else if (paramType == typeof (Vector2))
{
var args = paramRawValue.Split(',');
if (args.Length != 2)
throw new ArgumentException("Could not parse parameter " + paramName +
" as Vector2. Value: " + paramRawValue);
paramValue = new Vector2(float.Parse(args[0]), float.Parse(args[1]));
}
else if (paramType == typeof(Vector3))
{
var args = paramRawValue.Split(',');
if (args.Length != 3)
throw new ArgumentException("Could not parse parameter " + paramName +
" as Vector3. Value: " + paramRawValue);
paramValue = new Vector3(float.Parse(args[0]), float.Parse(args[1]), float.Parse(args[2]));
}
else if (paramType == typeof(Vector4))
{
var args = paramRawValue.Split(',');
if (args.Length != 4)
throw new ArgumentException("Could not parse parameter " + paramName +
" as Vector4. Value: " + paramRawValue);
paramValue = new Vector4(float.Parse(args[0]), float.Parse(args[1]), float.Parse(args[2]), float.Parse(args[3]));
}
else
{
throw new ArgumentException("Could not parse parameter " + paramName +
". Type not recognized. Value: " + paramRawValue);
}
var cparam = new ComponentParameter(paramName, paramValue);
_parameters[componentname].Add(cparam);
}
if (tComponent.Element("ExtendedParameters") != null)
{
_parameters[componentname].Add(new ComponentParameter("ExtendedParameters",
tComponent.Element("ExtendedParameters")));
}
}
XElement t_placementprops = templateElement.Element("PlacementProperties");
//Load Placement properties.
if (t_placementprops != null)
{
LoadPlacementProperties(t_placementprops);
}
else
{
PlacementMode = "AlignNone";
}
XElement tDescription = templateElement.Element("Description");
if (tDescription != null) Description = tDescription.Attribute("string").Value;
}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "AddEffect":
AddEffect(parameter.GetValue<string>(), 10);
break;
default:
base.SetParameter(parameter);
break;
}
}
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "MaxHealth":
maxHealth = parameter.GetValue<int>();
currentHealth = maxHealth;
break;
case "CurrentHealth":
currentHealth = parameter.GetValue<int>();
break;
}
}
/// <summary>
/// This allows setting of the component's parameters once it is instantiated.
/// This should basically be overridden by every inheriting component, as parameters will be different
/// across the board.
/// </summary>
/// <param name="parameter">ComponentParameter object describing the parameter and the value</param>
public virtual void SetParameter(ComponentParameter parameter)
{
}
/// <summary>
/// Parameter Setting
/// Settable params:
/// TweakAABB - Vector4
/// </summary>
/// <param name="parameter"></param>
public override void SetParameter(ComponentParameter parameter)
{
base.SetParameter(parameter);
switch (parameter.MemberName)
{
case "TweakAABB":
TweakAABB = parameter.GetValue<Vector4>() / IoCManager.Resolve<IMapManager>().TileSize;
break;
case "TweakAABBtop":
tweakAABB.X = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize;
break;
case "TweakAABBright":
tweakAABB.Y = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize;
break;
case "TweakAABBbottom":
tweakAABB.Z = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize;
break;
case "TweakAABBleft":
tweakAABB.W = parameter.GetValue<float>() / IoCManager.Resolve<IMapManager>().TileSize;
break;
case "DebugColor":
var color = ColorTranslator.FromHtml(parameter.GetValue<string>());
if (!color.IsEmpty)
DebugColor = color;
break;
}
}
public override void SetParameter(ComponentParameter parameter)
{
switch (parameter.MemberName)
{
case "damageAmount":
damageAmount = parameter.GetValue<int>();
break;
case "damageType":
if (parameter.ParameterType == typeof (string))
{
//Try to parse it. Set to Bludgeoning damagetype if parsing fails
if (!Enum.TryParse(parameter.GetValue<string>(), true, out damType))
damType = DamageType.Bludgeoning;
}
else if (parameter.ParameterType == typeof (DamageType))
{
damType = parameter.GetValue<DamageType>();
}
break;
case "startActive":
active = parameter.GetValue<bool>();
break;
case "toggleable":
toggleable = parameter.GetValue<bool>();
if (!toggleable)
active = true;
break;
case "inactiveSprite":
inactiveSprite = parameter.GetValue<string>();
break;
case "activeSprite":
activeSprite = parameter.GetValue<string>();
break;
}
}
