private static void VerifyNullableStructIsIEquatableOfStruct(S?value) { Expression <Func <bool> > e = Expression.Lambda <Func <bool> >( Expression.TypeIs(Expression.Constant(value, typeof(S?)), typeof(IEquatable <S>)), Enumerable.Empty <ParameterExpression>()); Func <bool> f = e.Compile(); // compute the value with the expression tree bool etResult = default(bool); Exception etException = null; try { etResult = f(); } catch (Exception ex) { etException = ex; } // compute the value with regular IL bool csResult = default(bool); Exception csException = null; try { csResult = value is IEquatable <S>; } catch (Exception ex) { csException = ex; } // either both should have failed the same way or they should both produce the same result if (etException != null || csException != null) { Assert.NotNull(etException); Assert.NotNull(csException); Assert.Equal(csException.GetType(), etException.GetType()); } else { Assert.Equal(csResult, etResult); } }
private TransitionRegex(SymbolicRegexBuilder <S> builder, TransitionRegexKind kind, S?test, TransitionRegex <S>?first, TransitionRegex <S>?second, SymbolicRegexNode <S>?node, DerivativeEffect?effect) { Debug.Assert(builder is not null); Debug.Assert( kind is TransitionRegexKind.Leaf && node is not null && Equals(test, default(S)) && first is null && second is null && effect is null || kind is TransitionRegexKind.Conditional && test is not null && first is not null && second is not null && node is null && effect is null || kind is TransitionRegexKind.Union && Equals(test, default(S)) && first is not null && second is not null && node is null && effect is null || kind is TransitionRegexKind.Lookaround && Equals(test, default(S)) && first is not null && second is not null && node is not null && effect is null || kind is TransitionRegexKind.Effect && Equals(test, default(S)) && first is not null && second is null && node is null && effect is not null); _builder = builder; _kind = kind; _test = test; _first = first; _second = second; _node = node; _effect = effect; }
internal void Add(S?state, A?action, DFlowAction method) { if (state == null) { AddAll(action, method); return; } if (!actions.ContainsKey(state)) { actions.Add(state, new NullableDict <A?, List <ActionHolder> >()); } if (!actions[state].ContainsKey(action)) { actions[state].Add(action, new List <ActionHolder>()); } actions[state][action].Add(new ActionHolder(__id++, method)); actions[state][action].Sort((a, b) => b.Id - a.Id); }
public static int Main() { S a = new S(); S? b = null; var res = a | b; if (res != "op") { return(1); } var res2 = a + b; if (res2 != 9) { return(2); } return(0); }
public static int Main() { S?s = null; S?s2 = new S(); long?i = s; if (i != null) { return(1); } double?ui = s2; if (ui == null) { return(2); } return(0); }
static int TestNullable() { int?i = 4; var m = i?.CompareTo(3); if (m.GetType() != typeof(int)) { return(1); } if (m != 1) { return(2); } DateTime?dt = null; dt?.ToString(); if (dt?.ToString() != null) { return(3); } byte?b = 0; if (b?.ToString() != "0") { return(4); } S? s = null; var p1 = s?.Prop; if (p1 != null) { return(5); } return(0); }
public static int Main() { S?nullable = null; using (var a = nullable) { } if (S.hit != 0) { return(1); } using (var s = new S()) { } if (S.hit != 1) { return(2); } C c = null; GenMethod(c); using (S? a = nullable, b = nullable) { } if (S.hit != 1) { return(3); } Console.WriteLine("ok"); return(0); }
public static int Main() { S?s = null; C c = (C)s; if (c.ID != 5) { return(1); } s = new S() { ID = 10 }; c = (C)s; if (c.ID != 10) { return(2); } return(0); }
public static void CheckNullableStructArrayListTest() { S?[][] array = new S?[][] { new S?[] { }, new S?[] { default(S) }, new S?[] { default(S), new S() } }; Expression[][] exprs = new Expression[array.Length][]; for (int i = 0; i < array.Length; i++) { exprs[i] = new Expression[array[i].Length]; for (int j = 0; j < array[i].Length; j++) { S?val = array[i][j]; exprs[i][j] = Expression.Constant(val, typeof(S?)); } } for (int i = 0; i < array.Length; i++) { VerifyNullableStructArrayList(array[i], exprs[i]); } }
static void Test(S?s) { Foo(s); }
public static IQueryable <T> CheckBetween <T, S>(this IQueryable <T> baseQuery, S valMin, S?valMax, Expression <Func <T, S?> > field, bool includeMin = true, bool includeMax = true) where S : struct { S?a = valMin; S?b = valMax; return(CheckBetween(baseQuery, a, b, field, includeMin, includeMax)); }
public static void Main() { S a = new S(); S? b = null; string res = a > b; }
public static IQueryable <T> CheckEqual <T, S>(this IQueryable <T> baseQuery, S?val, Expression <Func <T, S?> > field) where S : struct { if (val == null) { return(baseQuery); } else { var equal = Expression.Equal(Expression.PropertyOrField(field.Body, "Value"), Expression.Constant(val)); var where = Expression.Lambda <Func <T, bool> >(equal, field.Parameters[0]); return(baseQuery.Where(where)); } }
public static IQueryable <T> CheckBetween <T, S>(this IQueryable <T> baseQuery, S?valMin, S?valMax, Expression <Func <T, S?> > field, bool includeMin = true, bool includeMax = true) where S : struct { if (valMin == null && valMax == null) { return(baseQuery); } else { BinaryExpression exp1 = null; BinaryExpression exp2 = null; BinaryExpression exp = null; if (valMin != null) { exp1 = !includeMin?Expression.GreaterThan(Expression.PropertyOrField(field.Body, "Value"), Expression.Constant(valMin)) : Expression.GreaterThanOrEqual(Expression.PropertyOrField(field.Body, "Value"), Expression.Constant(valMin)); } if (valMax != null) { exp2 = !includeMax?Expression.LessThan(Expression.PropertyOrField(field.Body, "Value"), Expression.Constant(valMax)) : Expression.LessThanOrEqual(Expression.PropertyOrField(field.Body, "Value"), Expression.Constant(valMax)); } if (exp1 != null && exp2 != null) { exp = Expression.And(exp1, exp2); } else { exp = exp1 ?? exp2; } var where = Expression.Lambda <Func <T, bool> >(exp, field.Parameters[0]); return(baseQuery.Where(where)); } }
public static void Test (S? s) { C<S?>.Foo (s); C<ValueType>.Foo (s); C<object>.Foo (s); }
static void Bar(S?s) { C <I> .Foo(s); }
public MachineTransitionBinding <E, S> Transit(S state) { this.state = state; return(this); }
static void TestStruct2(S?s = new S?()) { }
public Transition() { Call = null; Next = null; }
public MachineTransitionBinding(E e) { this.e = e; this.call = null; this.state = null; }
public static int Main() { S?s = new S(); S?s2 = null; S?s4 = null; if ((s == s2) != false) { return(1); } if ((s2 == s) != false) { return(2); } if ((s2 == s4) != true) { return(3); } S x = new S(); if ((s2 == x) != false) { return(5); } if ((x == s2) != false) { return(6); } S2?s2_1 = new S2(); S2?s2_3 = new S2(); S2 x2 = new S2(); if ((s2_1 == s2_3) != true) { return(7); } if ((s2_1 == x2) != true) { return(8); } if ((x2 == s2_1) != true) { return(9); } if (S2.counter != 3) { return(10); } S3 s3; if ((s3 == null) != true) { return(20); } if ((null == s3) != true) { return(21); } if (S3.counter != 2) { return(22); } return(0); }
static void TestStruct(S?s = new S()) { }
private static TransitionRegex <S> GetOrCreate(SymbolicRegexBuilder <S> builder, TransitionRegexKind kind, S?test, TransitionRegex <S>?one, TransitionRegex <S>?two, SymbolicRegexNode <S>?node, DerivativeEffect?effect = null) { // Keep transition regexes internalized using the builder ref TransitionRegex <S>?tr = ref CollectionsMarshal.GetValueRefOrAddDefault(builder._trCache, (kind, test, one, two, node, effect), out _);
/// <summary> /// Initializes a new instance of the <see cref="T:ListDiff.ListDiffAction`2"/> class. /// </summary> /// <param name="type">The <see cref="ActionType"/></param> /// <param name="source">The <see cref="SourceItem"/></param> /// <param name="dest">The <see cref="DestinationItem"/></param> public ListDiffAction(ListDiffActionType type, S?source, D?dest) { ActionType = type; SourceItem = source; DestinationItem = dest; }
static void Test(S?s) { C <S> .Foo(s); }