public static void Returns <T>(this object target, T value)
{
var invocation = CallContext <IMethodInvocation> .GetData(nameof(IMethodInvocation));
var mock = ((IMocked)invocation.Target).Mock;
var currentMatchers = CallContext <Stack <IArgumentMatcher> > .GetData(nameof(IArgumentMatcher), () => new Stack <IArgumentMatcher>());
var finalMatchers = new List <IArgumentMatcher>();
var parameters = invocation.MethodBase.GetParameters();
for (var i = 0; i < invocation.Arguments.Count; i++)
{
var argument = invocation.Arguments[i];
var parameter = parameters[i];
if (object.Equals(argument, DefaultValue.For(parameter.ParameterType)) &&
currentMatchers.Count != 0 &&
parameter.ParameterType.GetTypeInfo().IsAssignableFrom(currentMatchers.Peek().ArgumentType.GetTypeInfo()))
{
finalMatchers.Add(currentMatchers.Pop());
}
else
{
finalMatchers.Add(new ConstantArgumentMatcher(parameter.ParameterType, argument));
}
}
mock.Invocations.Remove(invocation);
mock.AddMockBehavior(new ArgumentMatcherFilter(invocation, finalMatchers).AppliesTo, (mi, next) => mi.CreateValueReturn(value, mi.Arguments));
}
private string GetDefaultValueText(DefaultValue defaultValue)
{
Verify.ArgumentNotNull(defaultValue, "defaultValue");
switch (defaultValue.ValueType)
{
case DefaultValueType.DateTimeNow:
return("getdate()");
case DefaultValueType.String:
case DefaultValueType.Guid:
return("N" + SqlQuoted(defaultValue.Value));
case DefaultValueType.NewGuid:
return("newid()");
case DefaultValueType.Integer:
return(defaultValue.Value.ToString());
case DefaultValueType.Boolean:
return((bool)defaultValue.Value ? "1" : "0");
case DefaultValueType.DateTime:
return(SqlQuoted(((DateTime)defaultValue.Value).ToString("yyyy-MM-dd HH:mm:ss")));
case DefaultValueType.Decimal:
return(((decimal)defaultValue.Value).ToString("F", CultureInfo.InvariantCulture));
}
throw new NotImplementedException("Supplied DefaultValue contains an unsupported DefaultValueType '{0}'."
.FormatWith(defaultValue.ValueType));
}
public override object ToSqlValue(object instanceValue, out bool needToUpdateInstance)
{
needToUpdateInstance = false;
if (instanceValue == null || IsDefaultDatetimeValue(instanceValue))
{
if (AllowsNulls)
{
return(null);
}
needToUpdateInstance = true;
if (Constants.DefaultValue.DateTimeNow.Equals(DefaultValue))
{
return(DateTime.Now);
}
if (DefaultValue == null)
{
throw new NotSupportedException("You must provide default value for non nullable field.");
}
return(DateTime.Parse(DefaultValue.ToString()));
}
if (instanceValue == DBNull.Value)
{
return(instanceValue);
}
needToUpdateInstance = true;
instanceValue = RoundToSqlDateTime((DateTime)instanceValue);
return(instanceValue);
}
public GenericStdFunctionProcess(DefaultValue defaultValue, ConvertFrom <T> convertFrom, ProcessAction <T> processAction, int count)
: base(0, count > 0 ? count - 1 : 0, 0)
{
this.defaultValue = defaultValue;
this.processAction = processAction;
this.convertFrom = convertFrom;
}
public int CompareTo(string other)
{
if (other.Length == 4)
{
return(1);
}
var searchType = other.Substring(0, 3);
var searchValue = other.Substring(4);
switch (searchType)
{
case "key":
return((Key == null ? false :
Key.IndexOf(searchValue, StringComparison.OrdinalIgnoreCase) > -1)
? 1 : 0);
default:
case "val":
return((DefaultValue == null ? false :
DefaultValue.IndexOf(searchValue, StringComparison.OrdinalIgnoreCase) > -1)
? 1 : 0);
case "trs":
return((TranslationValue == null ? false :
TranslationValue.IndexOf(searchValue, StringComparison.OrdinalIgnoreCase) > -1)
? 1 : 0);
}
}
public GenericStdFunctionProcess(DefaultValue defaultValue, ProcessAction <T> processAction, int firstInput, int lastInput, int output)
: base(firstInput, lastInput, output)
{
this.defaultValue = defaultValue;
this.processAction = processAction;
this.convertFrom = delegate(IValueStructure value) { return((T)value); };
}
public GenericStdFunctionProcess(DefaultValue defaultValue, ProcessAction <T> processAction, ConvertFrom <T> convertFrom, int firstInput, int lastInput, int output)
: base(firstInput, lastInput, output)
{
this.defaultValue = defaultValue;
this.processAction = processAction;
this.convertFrom = convertFrom;
}
public GenericStdFunctionProcess(DefaultValue defaultValue, ProcessAction <T> processAction, bool[] inInput, bool[] inInternal, bool[] outOutput, bool[] outInternal)
: base(inInput, inInternal, outOutput, outInternal)
{
this.defaultValue = defaultValue;
this.processAction = processAction;
this.convertFrom = delegate(IValueStructure value) { return((T)value); };
}
public bool Equals(IndicatorParameter <T> ip)
{
bool result = true;
if ((object)ip == null)
{
return(false);
}
if (Name != ip.Name)
{
result = false;
}
else if (DataType != ip.DataType)
{
result = false;
}
else if (Description != ip.Description)
{
result = false;
}
else if (!DefaultValue.Equals(ip.DefaultValue))
{
result = false;
}
else if (!Value.Equals(ip.Value))
{
result = false;
}
return(result);
}
/// <summary>
/// 插入，支持主键自动获取。
/// </summary>
/// <param name="poco">对象</param>
/// <returns></returns>
public object Insert <T>(T poco) where T : class
{
if (poco == null)
{
throw new ArgumentNullException("poco is null");
}
if (poco is IList)
{
throw new ArgumentException("poco is a list type, use InsertList methon .");
}
if (_setDateTimeDefaultNow || _setStringDefaultNotNull || _setGuidDefaultNew)
{
DefaultValue.SetDefaultValue <T>(poco, _setStringDefaultNotNull, _setDateTimeDefaultNow, _setGuidDefaultNew);
}
if (_Events.OnBeforeInsert(poco))
{
return(null);
}
var obj = getDatabase().Insert(poco);
_Events.OnAfterInsert(poco);
return(obj);
}
void ISqlFormattable.AppendTo(SqlStringBuilder builder)
{
builder.Append(Name);
builder.Append(" ");
ParameterType.AppendTo(builder);
if (Direction != SqlParameterDirection.In)
{
builder.Append(" ");
if (IsInput)
{
builder.Append("INPUT");
}
if (IsInput && IsOutput)
{
builder.Append(" ");
}
if (IsOutput)
{
builder.Append("OUTPUT");
}
}
if (HasDefaultValue)
{
builder.Append(" := ");
DefaultValue.AppendTo(builder);
}
}
public virtual object GetValue()
{
if (!RowData.Keys.Contains(FieldName) || RowData[FieldName] == null || RowData[FieldName].ToString().IsNullOrEmpty())
{
RowData[FieldName] = DefaultValue.IsNullOrEmpty() ? string.Empty : DefaultValue;
}
object result = RowData[FieldName];
if (ColumnConverter != null)
{
result = ColumnConverter.Converter(FieldName, result, RowData);
}
else
{
if (!DataFormatString.IsNullOrEmpty() && !HtmlEncode)
{
if (!DataFormatFields.IsNullOrEmpty())
{
var dataFields = DataFormatFields.Split(',');
object[] param = new object[dataFields.Length];
for (int i = 0; i < dataFields.Length; i++)
{
param[i] = RowData[dataFields[i]];
}
result = string.Format(CultureInfo.CurrentCulture, DataFormatString, param);
}
else
{
result = string.Format(CultureInfo.CurrentCulture, DataFormatString, new object[] { result });
}
}
}
return(result);
}
public GenericStdFunctionProcess(DefaultValue defaultValue, ProcessAction <T> processAction, ConvertFrom <T> convertFrom, bool[] inInput, bool[] inInternal, bool[] outOutput, bool[] outInternal)
: base(inInput, inInternal, outOutput, outInternal)
{
this.defaultValue = defaultValue;
this.processAction = processAction;
this.convertFrom = convertFrom;
}
private void SetDefaultValue(DefaultValue value)
{
this.defaultValue = value;
this.defaultValueProvider = defaultValue == DefaultValue.Mock
? new MockDefaultValueProvider(this)
: new EmptyDefaultValueProvider();
}
public object GetDefaultValue(Type type)
{
foreach (var info in _schemas)
{
var o = info.GetDefaultValue(type);
if (o.IsSome)
{
return(o.Value);
}
}
if (type.IsEnum)
{
var mapValues = GetMapValues(type);
if (mapValues != null)
{
var fields =
from f in mapValues
where f.MapValues.Any(a => a.Value == null)
select f.OrigValue;
var value = fields.FirstOrDefault();
if (value != null)
{
SetDefaultValue(type, value);
return(value);
}
}
}
return(DefaultValue.GetValue(type, this));
}
public PropertyArgumentDef(
PropertyInfo propertyInfo,
CommandNodeType commandNodeType,
AppConfig appConfig,
object modelInstance)
{
if (modelInstance == null)
{
throw new ArgumentNullException(nameof(modelInstance));
}
_propertyInfo = propertyInfo ?? throw new ArgumentNullException(nameof(propertyInfo));
CommandNodeType = commandNodeType;
Name = propertyInfo.BuildName(commandNodeType, appConfig);
DefaultValue = propertyInfo.GetValue(modelInstance);
ValueProxy = new ValueProxy(
() => _propertyInfo.GetValue(modelInstance),
value => _propertyInfo.SetValue(modelInstance, value)
);
// Enhancement: AppSetting.StrictDefaults: show any default values that will be used.
// If a value type doesn't have a default, it would be defined as a nullable type.
// Keeping this behavior for legacy support.
if (DefaultValue.IsDefaultFor(propertyInfo.PropertyType))
{
DefaultValue = DBNull.Value;
}
HasDefaultValue = DefaultValue != DBNull.Value;
}
public EmailApiCommand(string _method)
{
method = _method;
accessId = new DefaultValue<string>(() => (string)this.SessionState.PSVariable.GetValue(AccessIdVariable, null));
secretKey = new DefaultValue<string>(() => (string)this.SessionState.PSVariable.GetValue(SecretKeyVariable, null));
baseUrl = new DefaultValue<string>(() => (string)this.SessionState.PSVariable.GetValue(BaseUrlVariable, null));
}
public void DefaultValueForArrayWithRank()
{
var array = new int[0][][];
var value = new DefaultValue().For(array.GetType());
Assert.Equal(array.GetType().GetArrayRank(), value.GetType().GetArrayRank());
}
/// <summary>
/// Invokes the given delegate when the setup method is invoked, typically used
/// to access and set ref/out arguments in a typed fashion. Used in combination
/// with <see cref="SetupExtension.Setup{TDelegate}(object, TDelegate)"/>.
/// </summary>
/// <typeparam name="TDelegate">The lambda to invoke when the setup method runs.</typeparam>
/// <param name="target">The setup being performed.</param>
/// <param name="handler">The lambda to invoke when the setup is matched.</param>
public static void Returns <TDelegate>(this ISetup <TDelegate> target, TDelegate handler)
{
using (new SetupScope())
{
var @delegate = handler as Delegate;
// Simulate Any<T> matchers for each member parameter
var parameters = @delegate.Method.GetParameters();
var arguments = new object[parameters.Length];
var defaultValue = new DefaultValue(false);
for (var i = 0; i < arguments.Length; i++)
{
var parameter = parameters[i];
MockSetup.Push(new AnyMatcher(parameter.IsOut ? parameter.ParameterType.GetElementType() : parameter.ParameterType));
if (!parameter.IsOut)
{
arguments[i] = defaultValue.For(parameter.ParameterType);
}
}
target.Delegate.DynamicInvoke(arguments);
// Now we'd have a setup in place and an actual invocation.
var setup = MockContext.CurrentSetup;
if (setup != null)
{
setup.Invocation.Target
.GetMock()
.GetPipeline(setup)
.Behaviors.Add(new ReturnsDelegateBehavior(@delegate));
}
}
}
/// <summary>
/// 插入集合，不返回主键
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list"></param>
public void InsertList <T>(List <T> list) where T : class
{
if (list == null)
{
throw new ArgumentNullException("list is null.");
}
if (list.Count == 0)
{
return;
}
if (_setDateTimeDefaultNow || _setStringDefaultNotNull || _setGuidDefaultNew)
{
foreach (var item in list)
{
DefaultValue.SetDefaultValue <T>(item, _setStringDefaultNotNull, _setDateTimeDefaultNow, _setGuidDefaultNew);
}
}
if (_Events.OnBeforeInsert(list))
{
return;
}
getDatabase().Insert(list);
_Events.OnAfterInsert(list);
}
public void Return_value_set_if_vaue_is_set_with_no_default()
{
var variable = new DefaultValue<string>();
variable.Value = "1";
Assert.That(variable.Value, Is.EqualTo("1"));
}
public void Return_value_even_if_all_defaults_are_value()
{
var variable = new DefaultValue<string>(() => "2", () => "3");
variable.Value = "1";
Assert.That(variable.Value, Is.EqualTo("1"));
}
//edit meta field
public void BindData(MetaField mf)
{
ViewState[this.ClientID + "_TypeName"] = mf.TypeName;
MetaFieldType mft = DataContext.Current.MetaModel.RegisteredTypes[mf.TypeName];
trName.Visible = false;
trFriendlyName.Visible = false;
txtFriendlyName.Text = mft.FriendlyName;
DataTable dt = GetDataTable().Copy();
object defaultValue = DefaultValue.Evaluate(mf);
if (defaultValue != null)
{
List <int> lst = new List <int>((int[])defaultValue);
foreach (DataRow dr in dt.Rows)
{
if (lst.Contains((int)dr["Id"]))
{
dr["IsDefault"] = true;
string sDef = String.Empty;
if (ViewState[this.ClientID + "_IsDefaultId"] != null)
{
sDef = ViewState[this.ClientID + "_IsDefaultId"].ToString();
}
if (!String.IsNullOrEmpty(sDef))
{
sDef += ",";
}
sDef += dr["Id"].ToString();
ViewState[this.ClientID + "_IsDefaultId"] = sDef;
}
}
}
ViewState[this.ClientID + "_DataSource"] = dt;
BindGrid(dt);
if (mf.Attributes.ContainsKey(McDataTypeAttribute.EnumEditable))
{
chkEditable.Checked = (bool)mf.Attributes[McDataTypeAttribute.EnumEditable];
}
if (mft.Attributes.ContainsKey(McDataTypeAttribute.EnumPrivate) &&
mft.Attributes[McDataTypeAttribute.EnumPrivate].ToString() == mf.Owner.Name)
{
chkPublic.Checked = false;
}
else
{
chkPublic.Checked = true;
}
chkPublic.Enabled = false;
}
/// <summary>
/// Reads the specified registry key and value and appends it to
/// the passed <see cref="StringBuilder"/>.
/// </summary>
/// <param name="builder">The <see cref="StringBuilder"/> to append the rendered data to.</param>
/// <param name="logEvent">Logging event. Ignored.</param>
protected override void Append(StringBuilder builder, LogEventInfo logEvent)
{
object registryValue = null;
// Value = null is necessary for querying "unnamed values"
string renderedValue = Value?.Render(logEvent);
var parseResult = ParseKey(Key.Render(logEvent));
try
{
#if !NET35
using (RegistryKey rootKey = RegistryKey.OpenBaseKey(parseResult.Hive, View))
#else
var rootKey = MapHiveToKey(parseResult.Hive);
#endif
{
if (parseResult.HasSubKey)
{
using (RegistryKey registryKey = rootKey.OpenSubKey(parseResult.SubKey))
{
if (registryKey != null)
{
registryValue = registryKey.GetValue(renderedValue);
}
}
}
else
{
registryValue = rootKey.GetValue(renderedValue);
}
}
}
catch (Exception ex)
{
if (LogManager.ThrowExceptions)
{
throw;
}
InternalLogger.Error(ex, "Error when reading from registry");
}
string value = null;
if (registryValue != null) // valid value returned from registry will never be null
{
value = Convert.ToString(registryValue, CultureInfo.InvariantCulture);
}
else if (DefaultValue != null)
{
value = DefaultValue.Render(logEvent);
if (RequireEscapingSlashesInDefaultValue)
{
//remove escape slash
value = value.Replace("\\\\", "\\");
}
}
builder.Append(value);
}
/// <summary>
/// Returns a hash code for this instance.
/// </summary>
/// <returns>
/// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.
/// </returns>
public override int GetHashCode()
{
unchecked
{
int hashCode = 33 + GetHashCode(PossibleValues);
return(DefaultValue == null ? hashCode : hashCode ^ DefaultValue.GetHashCode());
}
}
// Public Methods
public string GetPhpCode(PhpEmitStyle s)
{
s = s ?? new PhpEmitStyle();
var eq = s.Compression == EmitStyleCompression.Beauty ? " = " : "=";
var d = DefaultValue != null ? eq + DefaultValue.GetPhpCode(s) : "";
return(string.Format("${0}{1}", _name, d));
}
public Guid?AsGuid()
{
if (DefaultValue == null)
{
return(null);
}
return(new Guid(DefaultValue.ToString()));
}
public override Expression Reduce()
{
return(Constant(
_mappingSchema == null ?
DefaultValue.GetValue(Type) :
_mappingSchema.GetDefaultValue(Type),
Type));
}
/// <summary>
/// Returns a hash code for this instance.
/// </summary>
/// <returns>
/// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.
/// </returns>
public override int GetHashCode()
{
unchecked
{
int hashCode = 17 + AllowNull.GetHashCode() ^ ReadOnly.GetHashCode() + 31 * GetHashCode(PossibleValues);;
return((DefaultValue == null) ? hashCode : hashCode *32 ^ DefaultValue.GetHashCode());
}
}
public MultiTextBox(string id, EasyUICtrlPrepareData pData)
: base(id, pData)
{
if (_dataOption.Count == 0)
{
_dataOption = DefaultValue.MultiTextBoxJson().JsonToDictionary();
}
}
private void ValidateDefaultValue()
{
if ((DefaultValue == null && MemberType.IsValueType && Nullable.GetUnderlyingType(MemberType) == null) ||
(DefaultValue != null && DefaultValue.GetType() != MemberType))
{
throw new JsonException($"Default value type mismatch");
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="enclosing"></param>
/// <param name="structureElement"></param>
public Field(object enclosing, StructureElement structureElement)
{
Enclosing = enclosing;
StructureElement = structureElement;
Value = new DefaultValue(this);
DeclaredElements = null;
}
void CheckDefaultValue()
{
if (DefaultValue == null)
{
if (UseDefWhenNoArg)
{
throw new ConfException(
$"Argument [{Name}]: {nameof(UseDefWhenNoArg)} is true but DefaultValue is not provided");
}
return;
}
if (Mandatory && UseDefWhenNoArg)
{
throw new ConfException(
$"Argument [{Name}]: {nameof(DefaultValue)} is provided, {nameof(UseDefWhenNoArg)} is true, but {nameof(Mandatory)} is true");
}
if (!ValueIsCollection && IsCollection(DefaultValue))
{
throw new ConfException(
$"DefaultValue cannot be a collection if field type is not a collection");
}
if (IsCollection(DefaultValue))
{
var l = new List <object>();
foreach (object defValItem in (IEnumerable)DefaultValue)
{
if (!CheckAllowedValueType(defValItem.GetType()))
{
throw new ConfException(
$"Argument [{Name}]: DefaultValue must be of type {ValueType.Name} or collection of it, but it is of type {defValItem.GetType().Name}");
}
object o = DeserializeAndCheckValueMaybeString(defValItem, false);
l.Add(o);
}
DefaultValueEffective = CreateSameCollection(l);
CheckValuesCollection(DefaultValueEffective, false);
}
else
{
if (!CheckAllowedValueType(DefaultValue.GetType()))
{
throw new ConfException(
$"Argument [{Name}]: DefaultValue must be of type {ValueType.Name} or collection of it, but it is of type {DefaultValue.GetType().Name}");
}
object o = DeserializeAndCheckValueMaybeString(DefaultValue, false);
DefaultValueEffective =
ValueIsCollection ? CreateSameCollection(new List <object> {
o
}) : o;
if (ValueIsCollection)
{
CheckValuesCollection(DefaultValueEffective, false);
}
}
}
/// <summary>
/// return byte given default value and using given encoding
/// </summary>
/// <param name="defaultValue"></param>
/// <param name="encoding"></param>
/// <returns></returns>
private static byte GetByte(DefaultValue defaultValue, Encoding encoding)
{
switch (defaultValue)
{
case DefaultValue.Space:
return encoding.GetBytes(" ")[0];
case DefaultValue.Zero:
return encoding.GetBytes("0")[0];
default: //including DefaultValue.LowValue:
return 0;
}
}
public void DoesNotAffectMockDefaultValueSetting(DefaultValue defaultValue)
{
// Fixture setup
var request = new Mock<IInterfaceWithProperty>()
{
DefaultValue = defaultValue
};
var context = new Mock<ISpecimenContext>().Object;
var sut = new StubPropertiesCommand();
// Exercise system
sut.Execute(request, context);
// Verify outcome
Assert.Equal(defaultValue, request.DefaultValue);
}
public ShadingForm(ColorDisplayType disType, DefaultValue defaultValue)
{
this.components = null;
this.InitializeComponent();
this.m_CurrentDisplayType = disType;
if (!defaultValue.Equals(null))
{
this.numericTextBox_First.Value = (decimal) defaultValue.m_StartValue;
this.numericTextBox_Last.Value = (decimal) defaultValue.m_EndValue;
this.numericTextBox_Interval.Value = (decimal) defaultValue.m_Space;
this.popupColorButton_Start.SelectedColor = defaultValue.m_StartColor;
this.popupColorButton_EndColor.SelectedColor = defaultValue.m_EndColor;
}
}
public MockInvocation(Mock mock, ICallContext invocation, Match matcher)
{
this.Mock = mock;
this.Invocation = invocation;
this.Match = matcher;
defaultValue = mock.DefaultValue;
// Temporarily set mock default value to Mock so that recursion works.
mock.DefaultValue = DefaultValue.Mock;
}
public void Return_default_value_if_value_is_never_set()
{
var variable = new DefaultValue<string>(() => "2");
Assert.That(variable.Value, Is.EqualTo("2"));
}
public void Return_null_if_value_is_never_set_with_no_default()
{
var variable = new DefaultValue<string>();
Assert.That(variable.Value, Is.Null);
}
public void Return_second_default_if_nothing_else_is_valid()
{
var variable = new DefaultValue<string>(() => null, () => "2");
Assert.That(variable.Value, Is.EqualTo("2"));
}
public void DefaultValueTest()
{
var s1 = new DefaultValue();
Assert.AreEqual("nope", s1.A);
}
private Expression ParseTypeofSizeofOrDefault(TokenSet followers)
//^ requires this.currentToken == Token.Typeof || this.currentToken == Token.Sizeof || this.currentToken == Token.Default;
//^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile;
{
Token tok = this.currentToken;
SourceLocationBuilder slb = new SourceLocationBuilder(this.scanner.SourceLocationOfLastScannedToken);
this.GetNextToken();
this.Skip(Token.LeftParenthesis);
TypeExpression type = this.ParseTypeExpression(false, true, followers|Token.RightParenthesis);
slb.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken);
this.SkipOverTo(Token.RightParenthesis, followers);
Expression result;
if (tok == Token.Typeof)
result = new TypeOf(type, slb);
else if (tok == Token.Sizeof)
result = new SizeOf(type, slb);
else {
//^ assert tok == Token.Default;
result = new DefaultValue(type, slb);
}
//^ assume followers[this.currentToken] || this.currentToken == Token.EndOfFile;
return result;
}
