Assert

System\Data\Common\CommandTrees\AbstractExpressions.cs (5)

340Debug.Assert(type != null, string.Format(CultureInfo.InvariantCulture, "{0}.Type is null in DbExpression constructor", this.GetType().Name)); 345Debug.Assert(type.IsReadOnly, "Editable type metadata specified for DbExpression.Type"); 739Debug.Assert(left != null, "DbBinaryExpression.Left cannot be null"); 740Debug.Assert(right != null, "DbBinaryExpression.Right cannot be null"); 768Debug.Assert(argument != null, "DbUnaryExpression.Argument cannot be null");

System\Data\Common\CommandTrees\Aggregates.cs (4)

32Debug.Assert(resultType != null, "DbAggregate.ResultType cannot be null"); 33Debug.Assert(arguments != null, "DbAggregate.Arguments cannot be null"); 34Debug.Assert(arguments.Count == 1, "DbAggregate requires a single argument"); 78Debug.Assert(function != null, "DbFunctionAggregate.Function cannot be null");

System\Data\Common\CommandTrees\BasicExpressionVisitor.cs (1)

520Debug.Assert(expression.RelatedEntityReferences != null, "HasRelatedEntityReferences returned true for null RelatedEntityReferences list?");

System\Data\Common\CommandTrees\DbLambda.cs (5)

32Debug.Assert(variables != null, "DbLambda.Variables cannot be null"); 33Debug.Assert(bodyExp != null, "DbLambda.Body cannot be null"); 692Debug.Assert(lambdaMethod != null, "Lambda function method must not be null"); 695Debug.Assert(paramNames.Length == argumentTypes.Length, "Lambda function method parameter count does not match argument count"); 699Debug.Assert(argumentTypes[idx] != null, "DbLambda.Create allowed null type argument");

System\Data\Common\CommandTrees\DefaultExpressionVisitor.cs (7)

146Debug.Assert(newArguments.Count == 1, "Function aggregate had more than one argument?"); 170Debug.Assert(newArguments.Count == 1, "Group aggregate had more than one argument?"); 316Debug.Assert(source.DeclaringType.EdmEquals(target.DeclaringType), "Relationship ends not declared by same relationship type?"); 530Debug.Assert(!expression.WithTies, "Limit.WithTies == true?"); 918Debug.Assert(expression.ExpressionKind == DbExpressionKind.FullOuterJoin, "DbJoinExpression had ExpressionKind other than InnerJoin, LeftOuterJoin or FullOuterJoin?"); 945Debug.Assert(expression.ExpressionKind == DbExpressionKind.OuterApply, "DbApplyExpression had ExpressionKind other than CrossApply or OuterApply?"); 1042Debug.Assert(expression.ExpressionKind == DbExpressionKind.Any, "DbQuantifierExpression had ExpressionKind other than All or Any?");

System\Data\Common\CommandTrees\ExpressionBindings.cs (2)

40Debug.Assert(input != null, "DbExpressionBinding input cannot be null"); 41Debug.Assert(varRef != null, "DbExpressionBinding variable cannot be null");

System\Data\Common\CommandTrees\ExpressionBuilder\DbExpressionBuilder.cs (8)

1742Debug.Assert(method != null, "Ensure method is non-null before calling ExtractAlias"); 1744Debug.Assert(aliases.Length > 0, "Incompatible method: at least one parameter is required"); 1750Debug.Assert(method != null, "Ensure method is non-null before calling ExtractAlias"); 1807Debug.Assert(instance != null, "Ensure instance is non-null before calling TryGetAnonymousTypeValues"); 2704Debug.Assert(DbExpressionKind.CrossApply == applyKind || DbExpressionKind.OuterApply == applyKind, "Invalid ApplyType"); 2721Debug.Assert(DbExpressionKind.CrossJoin == joinKind || 2729Debug.Assert(null == joinCondition, "Condition should not be specified for CrossJoin"); 2734Debug.Assert(joinCondition != null, "Condition must be specified for non-CrossJoin");

System\Data\Common\CommandTrees\ExpressionBuilder\EdmFunctions.cs (2)

28Debug.Assert(!string.IsNullOrEmpty(functionName), "Function name must not be null"); 60Debug.Assert(arguments[idx] != null, "Ensure arguments are non-null before calling InvokeCanonicalFunction");

System\Data\Common\CommandTrees\ExpressionBuilder\Internal\ArgumentValidation.cs (29)

System\Data\Common\CommandTrees\ExpressionBuilder\Internal\EnumerableValidator.cs (3)

106Debug.Assert(map != null, "Set EnumerableValidator.ConvertElement before calling validate"); 107Debug.Assert(collect != null, "Set EnumerableValidator.CreateResult before calling validate"); 141Debug.Assert(name != null, "GetName should not produce null");

System\Data\Common\CommandTrees\Internal\ExpressionCopier.cs (3)

32Debug.Assert(targetWorkspace != null, "Metadata workspace is null"); 41Debug.Assert(expression != null, "expression is null"); 95Debug.Assert(null != candidateFunctions && candidateFunctions.Count > 0, "Perspective.TryGetFunctionByName returned true with null/empty function result list");

System\Data\Common\CommandTrees\Internal\ExpressionDumper.cs (1)

780Debug.Assert(groupAgg != null, "Invalid DbAggregate");

System\Data\Common\CommandTrees\Internal\ExpressionKeyGen.cs (2)

191Debug.Assert(TypeSemantics.IsScalarType(e.ResultType), "Non-scalar type constant expressions are not supported."); 645Debug.Assert(ga.Arguments.Count == 1, "Group aggregate must have one argument.");

System\Data\Common\CommandTrees\Internal\ExpressionPrinter.cs (7)

36Debug.Assert(expr != null, "Null DbExpression"); 43Debug.Assert(tree != null && tree.Predicate != null, "Invalid DbDeleteCommandTree"); 74Debug.Assert(tree != null, "Null DbFunctionCommandTree"); 93Debug.Assert(tree != null, "Null DbInsertCommandTree"); 135Debug.Assert(tree != null && tree.Predicate != null, "Invalid DbUpdateCommandTree"); 187Debug.Assert(tree != null, "Null DbQueryCommandTree"); 937Debug.Assert(groupAgg != null, "Invalid DbAggregate");

System\Data\Common\CommandTrees\Internal\ParameterRetriever.cs (2)

31Debug.Assert(tree != null, "Ensure command tree is non-null before calling ParamterRetriever.GetParameters"); 40Debug.Assert(expression != null, "Command tree subexpressions should never be null");

System\Data\Common\CommandTrees\Internal\PatternMatchRules.cs (2)

87Debug.Assert(rules.Count() != 0, "At least one PatternMatchRule is required"); 88Debug.Assert(rules.Where(r => r == null).Count() == 0, "Individual PatternMatchRules must not be null");

System\Data\Common\CommandTrees\Internal\Validator.cs (2)

48Debug.Assert(expression != null, "Ensure expression is non-null before calling ValidateExpression"); 52Debug.Assert(this.variableScopes.Count == 0, "Variable scope stack left in inconsistent state");

System\Data\Common\CommandTrees\Internal\ViewSimplifier.cs (4)

311Debug.Assert(singleKeyNameAndValue.Item1 == fkConstraint.FromProperties[0].Name, "Unexpected single key property name"); 517Debug.Assert(original != null, "Original expression cannot be null"); 527Debug.Assert(varName != null, "Variable name cannot be null"); 528Debug.Assert(replValues != null, "Replacement values cannot be null");

System\Data\Common\CommandTrees\OperatorExpressions.cs (31)

System\Data\Common\CommandTrees\RelationalExpressions.cs (35)

System\Data\Common\CommandTrees\ValueExpressions.cs (27)

System\Data\Common\DataRecord.cs (3)

35Debug.Assert(null != edmUsage && null != values, "null recordType or values"); 60Debug.Assert(Helper.IsRowType(_edmUsage.EdmType), "Edm type should be Row Type"); 67Debug.Assert(_values.Length == _recordInfo.FieldMetadata.Count, "wrong values array size");

System\Data\Common\DataRecordInfo.cs (2)

80Debug.Assert(null != metadata, "invalid attempt to instantiate DataRecordInfo with null metadata information"); 87Debug.Assert((BuiltInTypeKind.EdmProperty == member.BuiltInTypeKind) ||

System\Data\Common\DbProviderServices.cs (5)

45Debug.Assert(storeMetadata.StoreProviderManifest != null, "StoreItemCollection has null StoreProviderManifest?"); 93Debug.Assert(commandTree != null, "Ensure command tree is non-null before calling ValidateDataSpace"); 256Debug.Assert(parameter != null, "Validate parameter before calling SetParameterValue"); 257Debug.Assert(parameterType != null, "Validate parameterType before calling SetParameterValue"); 310Debug.Assert(factory != null, "Should have thrown on null");

System\Data\Common\DbXmlEnabledProviderManifest.cs (1)

79Debug.Assert(type is PrimitiveType, "DbXmlEnabledProviderManifest.GetFacetDescriptions(): Argument is not a PrimitiveType");

System\Data\Common\EntitySql\AST\AliasedExpr.cs (3)

28Debug.Assert(expr != null, "expr != null"); 29Debug.Assert(alias != null, "alias != null"); 45Debug.Assert(expr != null, "expr != null");

System\Data\Common\EntitySql\AST\DotExpr.cs (1)

81Debug.Assert(_names == null || _names.Length > 0, "_names must be null or non-empty");

System\Data\Common\EntitySql\AST\Identifier.cs (1)

30Debug.Assert(isEscaped || name[0] != '[', "isEscaped || name[0] != '['");

System\Data\Common\EntitySql\AST\Literal.cs (9)

155System.Diagnostics.Debug.Assert(sign[0] == '-' || sign[0] == '+', "sign symbol must be + or -"); 394Debug.Assert(isUnicode == ('N' == stringLiteralValue[0]), "invalid string literal value"); 413Debug.Assert(before % 2 == 0, "must have an even number of delimiters in the string literal"); 443Debug.Assert(null != binaryLiteralValue, "binaryStringLiteral must not be null"); 452Debug.Assert(startIndex <= endIndex, "startIndex <= endIndex"); 485Debug.Assert(false, "Invalid Hexadecimal Digit"); 502Debug.Assert(datetimeParts.Length >= 5, "datetime literal value must have at least 5 parts"); 530Debug.Assert(datetimeParts.Length >= 7, "datetime literal value must have at least 7 parts"); 581Debug.Assert(datetimeParts.Length >= 2, "time literal value must have at least 2 parts");

System\Data\Common\EntitySql\AST\MethodExpr.cs (2)

44Debug.Assert(expr != null, "expr != null"); 45Debug.Assert(args == null || args.Count > 0, "args must be null or a non-empty list");

System\Data\Common\EntitySql\AST\ParenExpr.cs (1)

27Debug.Assert(expr != null, "expr != null");

System\Data\Common\EntitySql\CqlLexerHelpers.cs (14)

106Debug.Assert(query != null, "query must not be null"); 107Debug.Assert(parserOptions != null, "parserOptions must not be null"); 331Debug.Assert(token != null, "IsEscapedIdentifier must not return null token"); 338Debug.Assert(token != null, "IsKeyword must not return null token"); 547Debug.Assert(!String.IsNullOrEmpty(literal), "literal must not be null or empty"); 548Debug.Assert(literalKind != AST.LiteralKind.Null, "literalKind must not be LiteralKind.Null"); 635Debug.Assert(ch == YY_EOF, "ch == YY_EOF"); 695Debug.Assert(-1 != literal.IndexOf('\''), "quoted literal value must have single quotes"); 696Debug.Assert(-1 != literal.LastIndexOf('\''), "quoted literal value must have single quotes"); 697Debug.Assert(literal.IndexOf('\'') != literal.LastIndexOf('\''), "quoted literal value must have 2 single quotes"); 698Debug.Assert(literal.Split(new char[] { '\'' }).Length == 3, "quoted literal value must have 2 single quotes"); 712Debug.Assert(literalPayload.IndexOf('\'') == -1, "quoted literal payload must not have single quotes"); 713Debug.Assert(literalPayload.LastIndexOf('\'') == -1, "quoted literal payload must not have single quotes"); 764Debug.Assert(null != binaryValue, "binaryValue must not be null");

System\Data\Common\EntitySql\CqlQuery.cs (6)

71Debug.Assert(parseResultInternal != null, "parseResultInternal != null post-condition FAILED"); 72Debug.Assert(parseResultInternal.CommandTree != null, "parseResultInternal.CommandTree != null post-condition FAILED"); 116Debug.Assert(lambda != null, "lambda != null post-condition FAILED"); 219Debug.Assert(parseResultInternal != null, "parseResultInternal != null post-condition FAILED"); 220Debug.Assert(parseResultInternal.CommandTree != null, "parseResultInternal.CommandTree != null post-condition FAILED"); 260Debug.Assert(null != lambda, "null != lambda post-condition FAILED");

System\Data\Common\EntitySql\EntitySqlParser.cs (1)

31Debug.Assert(null != perspective, "null perspective?");

System\Data\Common\EntitySql\FunctionOverloadResolver.cs (6)

137Debug.Assert(argTypesFlat.Count == rank.Length, "argTypesFlat.Count == rank.Length"); 158Debug.Assert(rank.Length == bestCandidateRank.Length, "composite ranks have different number of elements"); 259Debug.Assert(flatArgumentList.Count == flatOverloadParamList.Count, "flatArgumentList.Count == flatOverloadParamList.Count"); 288Debug.Assert(isPromotableTo(fromType, toType), "isPromotableTo(fromType, toType)"); 302Debug.Assert(fromType != null, "fromType != null"); 303Debug.Assert(toType != null, "toType != null");

System\Data\Common\EntitySql\ParseResult.cs (2)

59Debug.Assert(name != null, "name can not be null"); 60Debug.Assert(lambda != null, "lambda cannot be null");

System\Data\Common\EntitySql\SemanticAnalyzer.cs (89)

System\Data\Common\EntitySql\SemanticResolver.cs (41)

System\Data\Common\EntitySql\StaticContext.cs (17)

System\Data\Common\EntitySql\TypeResolver.cs (20)

39Debug.Assert(!String.IsNullOrEmpty(name), "name must not be empty"); 71Debug.Assert(x != null && y != null, "metadata members must not be null"); 77Debug.Assert(obj != null, "metadata member must not be null"); 102Debug.Assert(typeUsage != null, "typeUsage must not be null"); 120Debug.Assert(enumType != null, "enumType must not be null"); 121Debug.Assert(enumMember != null, "enumMember must not be null"); 141Debug.Assert(functionMetadata != null && functionMetadata.Count > 0, "FunctionMetadata must not be null or empty"); 159Debug.Assert(functionMetadata != null && functionMetadata.Count > 0, "FunctionMetadata must not be null or empty"); 273Debug.Assert(!String.IsNullOrEmpty(name), "name must not be null or empty"); 274Debug.Assert(functionInfo != null, "functionInfo != null"); 323Debug.Assert(!_resolveLeftMostUnqualifiedNameAsNamespaceOnly, "EnterBackwardCompatibilityResolution() is not reentrant."); 327Debug.Assert(this._resolveLeftMostUnqualifiedNameAsNamespaceOnly, "_resolveLeftMostUnqualifiedNameAsNamespaceOnly must be true."); 334Debug.Assert(name != null && name.Length > 0, "name must not be empty"); 345Debug.Assert(metadataMember != null, "metadata member name resolution must not return null"); 386Debug.Assert(member != null, "member != null"); 387Debug.Assert(_parserOptions.NameComparer.Equals(name, member.Name), "_parserOptions.NameComparer.Equals(name, member.Name)"); 403Debug.Assert(!String.IsNullOrEmpty(name), "name must not be empty"); 515Debug.Assert(name != null && length > 1 && length <= name.Length, "name must not be empty"); 537Debug.Assert(!String.IsNullOrEmpty(rightName), "rightName must not be empty"); 609Debug.Assert(names != null && names.Length > 0, "names must not be null or empty");

System\Data\Common\EntityUtil.cs (13)

251Debug.Assert(identifier != null, "identifier should not be null"); 955Debug.Assert(null != valueType, "null valueType"); 956Debug.Assert(null != destinationType, "null destinationType"); 972Debug.Assert(null != destinationType, "null value"); 1016Debug.Assert(!String.IsNullOrEmpty(relationshipName), "empty relationshipName"); 1249Debug.Assert(type != null, "The type cannot be null."); 1514Debug.Assert(null != (object)key, "Null entity key"); 1515Debug.Assert(null != entitySet, "Null entity set"); 1516Debug.Assert(null != entitySet.EntityContainer, "Null entity container in the entity set"); 1747Debug.Assert(null != values, "null values"); // use a different method if values can be null 1910Debug.Assert(assemblyName != null, "assemblyName should not be null at this point"); 1960Debug.Assert(e != null, "Unexpected null exception!"); 1973Debug.Assert(e != null, "Unexpected null exception!");

System\Data\Common\FieldNameLookup.cs (2)

40Debug.Assert(null != fieldNames[i], "MDAC 66681"); 53Debug.Assert(null != fieldNames[i], "MDAC 66681");

System\Data\Common\Internal\Materialization\ColumnMapKeyBuilder.cs (1)

252Debug.Assert(isRefType, "RefColumnMap is not of RefType?");

System\Data\Common\Internal\Materialization\Coordinator.cs (1)

316Debug.Assert(null == _handleClose, "more than one handler for a collection close 'event'");

System\Data\Common\Internal\Materialization\CoordinatorFactory.cs (1)

301Debug.Assert(null != result, "did you initialize the record states?");

System\Data\Common\Internal\Materialization\CoordinatorScratchpad.cs (1)

146Debug.Assert(nested.Depth == this.Depth + 1, "can only nest depth + 1");

System\Data\Common\Internal\Materialization\Shaper.cs (28)

System\Data\Common\Internal\Materialization\ShaperFactory.cs (1)

69Debug.Assert(mergeOption == _mergeOption, "executing a query with a different mergeOption than was used to compile the delegate");

System\Data\Common\Internal\Materialization\Translator.cs (12)

199Debug.Assert(columnMap is CollectionColumnMap, "root column map must be a collection for a query"); 218Debug.Assert(null != translator._rootCoordinatorScratchpad, "translating the root of the query must populate _rootCoordinatorBuilder"); // how can this happen? 422Debug.Assert(null != result, "no result?"); // just making sure we cover this in the switch statement. 458Debug.Assert(null != edmType, "no edmType?"); // edmType must not be null. 851Debug.Assert(left.Type == right.Type, "equals with different types"); 1004Debug.Assert(0 < keyColumns.Length, "empty keyColumns?"); 1219Debug.Assert(cSpaceType.BuiltInTypeKind == BuiltInTypeKind.EntityType, "Type was " + cSpaceType.BuiltInTypeKind); 1546Debug.Assert(columnMap.Type.EdmType.BuiltInTypeKind == BuiltInTypeKind.RowType, "RecordColumnMap without RowType?"); // we kind of depend upon this 2077Debug.Assert(Helper.IsGeographicType((PrimitiveType)columnType.EdmType) || Helper.IsGeometricType((PrimitiveType)columnType.EdmType), "Spatial primitive type is neither Geometry or Geography?"); 2095Debug.Assert(needsNullableCheck, "This is a nullable enum so needsNullableCheck should be true to emit code that handles null values read from the reader."); 2101Debug.Assert(!needsNullableCheck, "If the requested type is object there is no special handling for null values returned from the reader."); 2139Debug.Assert(null != type, "type required");

System\Data\Common\Internal\MultipartIdentifier.cs (1)

63Debug.Assert(-1 == leftQuote.IndexOf(separator) && -1 == rightQuote.IndexOf(separator) && leftQuote.Length == rightQuote.Length, "Incorrect usage of quotes");

System\Data\Common\QueryCache\CompiledQueryCacheEntry.cs (1)

77Debug.Assert(newPlan != null, "New plan cannot be null");

System\Data\Common\QueryCache\CompiledQueryCacheKey.cs (1)

31Debug.Assert(compareTo != null, "Comparison key should not be null");

System\Data\Common\QueryCache\EntityClientCacheKey.cs (6)

81Debug.Assert(null != otherObject, "otherObject must not be null"); 130Debug.Assert(TypeSemantics.IsPrimitiveType(type, PrimitiveTypeKind.String), "Update GetTypeUsageToken to return 'Xml' for Xml parameters"); 142Debug.Assert(TypeSemantics.IsPrimitiveType(type), "EntityParameter TypeUsage not a primitive type?"); 143Debug.Assert(!TypeSemantics.IsPrimitiveType(type, PrimitiveTypeKind.String), "String TypeUsage not derived from DbType.AnsiString, AnsiString, String, StringFixedLength or Xml?"); 167Debug.Assert(paramTypeUsage.Count == entityCommand.Parameters.Count, "entityParameter collection and query parameter collection must have the same number of entries"); 178Debug.Assert(paramTypeUsage.Count == entityCommand.Parameters.Count, "entityParameter collection and query parameter collection must have the same number of entries");

System\Data\Common\QueryCache\EntitySqlQueryCacheKey.cs (2)

80Debug.Assert(null != eSqlStatement, "eSqlStatement must not be null"); 118Debug.Assert(null != otherObject, "otherObject must not be null");

System\Data\Common\QueryCache\LinqQueryCacheKey.cs (2)

80Debug.Assert(null != expressionKey, "expressionKey must not be null"); 113Debug.Assert(null != otherObject, "otherObject must not be null");

System\Data\Common\QueryCache\QueryCacheManager.cs (6)

103Debug.Assert(maximumSize > 0, "Maximum size must be greater than zero"); 104Debug.Assert(loadFactor > 0 && loadFactor <= 1, "Load factor must be greater than 0.0 and less than or equal to 1.0"); 105Debug.Assert(recycleMillis >= 0, "Recycle period in milliseconds must not be negative"); 140Debug.Assert(null != inQueryCacheEntry, "qEntry must not be null"); 174Debug.Assert(null != key, "key must not be null"); 217Debug.Assert(null != queryCacheKey, "queryCacheKey must not be null");

System\Data\Common\QueryCache\ShaperFactoryQueryCacheKey.cs (1)

22Debug.Assert(null != columnMapKey, "null columnMapKey");

System\Data\Common\Utils\Boolean\BoolExpr.cs (1)

84Debug.Assert(null != candidates && 1 < candidates.Length, "must be at least one to pick");

System\Data\Common\Utils\Boolean\Solver.cs (13)

106Debug.Assert(null != children, "children must be specified"); 107Debug.Assert(2 <= children.Length, "must be at least 2 children"); 108Debug.Assert(children.All(child => child != null), "children must not be null"); 109Debug.Assert(children.All(child => child.IsSink()), "children must be sinks"); 110Debug.Assert(variable <= _variableCount, "variable out of range"); 260Debug.Assert(variable == vertex.Variable, 266Debug.Assert(variableAssigment < vertex.Children.Length, "variable assignment out of range"); 290Debug.Assert(vertex != null, "vertex must not be null"); 297Debug.Assert(_knownVertices.TryGetValue(vertex, out comparisonVertex) && 347Debug.Assert(2 <= vertex.Children.Length, "internal vertices must have at least 2 children"); 370Debug.Assert(null != (object)value1, "null key element"); 371Debug.Assert(null != (object)value2, "null key element"); 372Debug.Assert(null != (object)value3, "null key element");

System\Data\Common\Utils\Boolean\Vertex.cs (4)

53Debug.Assert(null != children, "internal vertices must define children"); 54Debug.Assert(2 <= children.Length, "internal vertices must have at least two children"); 55Debug.Assert(0 < variable, "internal vertices must have 0 < variable"); 58Debug.Assert(variable < child.Variable, "children must have greater variable");

System\Data\Common\Utils\Boolean\Visitor.cs (3)

130Debug.Assert(null != expression, "expression must be given"); 249Debug.Assert(null != context, "must provide a context"); 255Debug.Assert(null != expr, "must provide an expression");

System\Data\Common\Utils\ByValueEqualityComparer.cs (4)

75Debug.Assert(bytes != null, "Byte array cannot be null"); 86Debug.Assert(first != null && second != null, "Arguments cannot be null"); 115Debug.Assert(comparer != null, "Non-ByValue comparer cannot be null"); 128Debug.Assert(!((object.ReferenceEquals(x, DBNull.Value)) && (object.ReferenceEquals(y,DBNull.Value))), "object.ReferenceEquals should catch the case when both values are dbnull");

System\Data\Common\Utils\DisposableCollectionWrapper.cs (1)

20Debug.Assert(enumerable != null, "don't pass in a null enumerable");

System\Data\Common\Utils\Helpers.cs (2)

71Debug.Assert(args != null, "Ensure 'args' is non-null before calling Prepend"); 97Debug.Assert(nodes.Count > 0, "At least one node is required");

System\Data\Common\Utils\KeyToListMap.cs (1)

98Debug.Assert(m_map.ContainsKey(key), "key not registered in map");

System\Data\Common\Utils\Memoizer.cs (1)

116Debug.Assert(null != createValueDelegate, "delegate must be given");

System\Data\Common\Utils\MetadataHelper.cs (10)

222Debug.Assert(end.TypeUsage.EdmType.BuiltInTypeKind == BuiltInTypeKind.RefType, 226Debug.Assert(endType.BuiltInTypeKind == BuiltInTypeKind.EntityType, 243Debug.Assert(members.Count == 2, "only expecting two end members"); 248Debug.Assert(Object.ReferenceEquals(endMember, members[1]), "didn't match other member"); 446Debug.Assert(parentType != null, "Parent type not Entity Type ??"); 494Debug.Assert(!references.Contains(b), "Dictionary already has a --> b reference"); 595Debug.Assert(entitySet1.EntityContainer == entitySet2.EntityContainer, "EntityContainer must be the same for both the entity sets"); 620Debug.Assert(associationType.Members.Contains(endName), "EndName should be a valid name"); 634Debug.Assert(retValue == null, "There should be only one AssociationSet, given an assocationtype, end name and entity set"); 907Debug.Assert(sourceEntityType.DataSpace == DataSpace.OSpace && sourceEntityType.ClrType != null, "sourceEntityType must contain an ospace type");

System\Data\Common\Utils\ModifiableIteratorCollection.cs (3)

58Debug.Assert(false == IsEmpty, "Empty set - cannot remove any element"); 76Debug.Assert(m_currentIteratorIndex >= 0, "Iterator not started yet"); 113Debug.Assert(index < m_elements.Count, "Removing an entry with too high an index");

System\Data\Common\Utils\Set.cs (4)

306Debug.Assert(!_isReadOnly, "attempting to modify readonly collection"); 312Debug.Assert(other != null, "other set null"); 370Debug.Assert(null != x && null != y, "comparer must be used only in context of Dictionary/HashSet"); 376Debug.Assert(null != obj, "comparer must be used only in context of Dictionary/HashSet");

System\Data\Common\Utils\StringUtil.cs (2)

206Debug.Assert(args.Length > 0, "Formatting utilities must be called with at least one argument"); 213Debug.Assert(args.Length > 0, "Formatting utilities must be called with at least one argument");

System\Data\EntityClient\DbConnectionOptions.cs (1)

480Debug.Assert(null != connectionString, "null connectionstring");

System\Data\EntityClient\DbParameterCollectionHelper.cs (2)

222Debug.Assert((null != items) && (0 <= index) && (index < Count), "RemoveIndex, invalid"); 230Debug.Assert((null != items) && (0 <= index) && (index < Count), "Replace Index invalid");

System\Data\EntityClient\EntityCommand.cs (5)

555Debug.Assert(null != _commandDefinition, "_commandDefinition cannot be null"); 698Debug.Assert(null != _connection, "Connection must not be null at this point"); 718Debug.Assert(null != queryCacheManager,"QuerycacheManager instance cannot be null"); 736Debug.Assert(null != entityCommandDefinition, "out entityCommandDefinition must not be null"); 810Debug.Assert(null != _parameters, "_parameters must not be null");

System\Data\EntityClient\EntityCommandDefinition.cs (9)

76Debug.Assert(mappedCommandList.Count > 0, "empty providerCommandInfo collection and no exception?"); // this shouldn't ever happen. 91Debug.Assert(DbCommandTreeKind.Function == commandTree.CommandTreeKind, "only query and function command trees are supported"); 192Debug.Assert(storeResultType.EdmType.BuiltInTypeKind == BuiltInTypeKind.CollectionType, "FunctionImport currently supports only collection result type"); 194Debug.Assert(Helper.IsScalarType(elementType.EdmType) 226Debug.Assert(null != complexType, "we should have a complex type here"); 243Debug.Assert(functionCommandTree.DataSpace == DataSpace.CSpace, "map from CSpace->SSpace function"); 244Debug.Assert(functionCommandTree != null, "null functionCommandTree"); 245Debug.Assert(!functionCommandTree.EdmFunction.IsComposableAttribute, "functionCommandTree.EdmFunction must be non-composable."); 329Debug.Assert(TypeSemantics.IsScalarType(queryParameter.Value), "Non-scalar type used as query parameter type");

System\Data\EntityClient\EntityConnection.cs (3)

409Debug.Assert(_metadataWorkspace != null || _effectiveConnectionOptions != null, "The effective connection options is null, which should never be"); 755Debug.Assert(transaction != null || !EnlistedInUserTransaction, 969Debug.Assert(workspace.IsItemCollectionAlreadyRegistered(DataSpace.CSpace), "C-Space must be loaded before loading S or C-S space");

System\Data\EntityClient\EntityDataReader.cs (1)

508Debug.Assert(this.FieldCount == 0, "we have fields but no metadata?");

System\Data\EntityClient\EntityParameter.cs (2)

458Debug.Assert(typeUsage != null, "DbType.TryGetModelTypeUsage returned true for null TypeUsage?"); 508Debug.Assert(false, "The provided edmType is of an unknown primitive type.");

System\Data\EntityClient\EntityProviderServices.cs (2)

45Debug.Assert(commandTree != null, "Command Tree cannot be null"); 56Debug.Assert(commandTree != null, "Ensure command tree is non-null before calling ValidateDataSpace");

System\Data\EntityClient\NameValuePair.cs (1)

22System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(name), "empty keyname");

System\Data\EntityKey.cs (43)

System\Data\EntityModel\SchemaObjectModel\CollectionTypeElement.cs (1)

174Debug.Assert(_typeSubElement != null, "For attributes typeusage should have been resolved");

System\Data\EntityModel\SchemaObjectModel\EntityContainer.cs (4)

346Debug.Assert(error != AddErrorKind.MissingNameError, "Since entity container members are already resolved, name must never be empty"); 347Debug.Assert(this.ExtendingEntityContainer != null, "ExtendingEntityContainer must not be null"); 351Debug.Assert(error == AddErrorKind.DuplicateNameError, "Error must be duplicate name error"); 550Debug.Assert(left.ParentElement.ParentElement == right.ParentElement.ParentElement, "both end should belong to the same entity container");

System\Data\EntityModel\SchemaObjectModel\EntityContainerAssociationSet.cs (1)

120Debug.Assert(

System\Data\EntityModel\SchemaObjectModel\EntityContainerAssociationSetEnd.cs (1)

133Debug.Assert(set != null, "set parameter is null");

System\Data\EntityModel\SchemaObjectModel\EntityContainerEntitySet.cs (2)

184Debug.Assert(Schema.DataModel == SchemaDataModelOption.ProviderDataModel, "We shouldn't see this attribute unless we are parsing ssdl"); 196Debug.Assert(Schema.DataModel == SchemaDataModelOption.ProviderDataModel, "We shouldn't see this attribute unless we are parsing ssdl");

System\Data\EntityModel\SchemaObjectModel\EntityContainerRelationshipSet.cs (2)

53Debug.Assert(value != null, "relationship can never be set to null"); 188Debug.Assert(relationshipEnd != null, "relationshipEnd parameter is null");

System\Data\EntityModel\SchemaObjectModel\EntityKeyElement.cs (5)

83Debug.Assert(_keyProperties != null, "xsd should have verified that there should be atleast one property ref element"); 98Debug.Assert(_keyProperties != null, "xsd should have verified that there should be atleast one property ref element"); 104Debug.Assert(property != null, "This should never be null, since if we were not able to resolve, we should have never reached to this point"); 133Debug.Assert(property.TypeUsage != null, "For scalar type, typeusage must be initialized"); 149Debug.Assert(SchemaDataModelOption.ProviderDataModel == Schema.DataModel, "Invalid DataModel encountered");

System\Data\EntityModel\SchemaObjectModel\FacetDescriptionElement.cs (1)

148Debug.Assert(_facetDescription != null, "Did you forget to call CreateAndValidate first?");

System\Data\EntityModel\SchemaObjectModel\FacetEnabledSchemaElement.cs (1)

103Debug.Assert(this.Type == null, "This must be resolved exactly once");

System\Data\EntityModel\SchemaObjectModel\Function.cs (8)

73Debug.Assert(false, "Unexpected modifier: " + match.Groups["modifier"].Value); 93Debug.Assert(colKind == CollectionKind.None, "Unexpected CollectionKind"); 192Debug.Assert(value != null, "StoreFunctionName should never be set null value"); 203Debug.Assert(_returnTypeList.Count == 1, "Shouldn't use Type if there could be multiple return types"); 399Debug.Assert(Schema.DataModel != SchemaDataModelOption.ProviderManifestModel, "ProviderManifest cannot have ReturnType as an attribute"); 576Debug.Assert(error == AddErrorKind.Succeeded, "Since we are cloning a validated function, this should never fail."); 607Debug.Assert(Schema.DataModel == SchemaDataModelOption.ProviderDataModel, "We shouldn't see this attribute unless we are parsing ssdl"); 706Debug.Assert(false, "RemoveTypeModifier already checks for this");

System\Data\EntityModel\SchemaObjectModel\FunctionImportElement.cs (5)

115Debug.Assert(IsFunctionImport, "Only FunctionImport elkements specify EntitySets"); 116Debug.Assert(null != _container, "function imports must know container"); 142Debug.Assert(returnType.Type != null, "FunctionImport/ReturnType element must not have subelements."); 272Debug.Assert(returnType == null || returnType is ScalarType || returnType is SchemaEnumType || returnType is Relationship, 300Debug.Assert(

System\Data\EntityModel\SchemaObjectModel\ItemType.cs (1)

143System.Diagnostics.Debug.Assert(BaseType is SchemaEntityType, "ItemType.BaseType is not ItemType");

System\Data\EntityModel\SchemaObjectModel\KeyProperty.cs (1)

56Debug.Assert(false, "This method should never be used. Use other overload instead");

System\Data\EntityModel\SchemaObjectModel\ModelFunction.cs (1)

137Debug.Assert(ReturnTypeList.Count == 1, "returnTypeList should always be non-empty. Multiple ReturnTypes are only possible on FunctionImports.");

System\Data\EntityModel\SchemaObjectModel\NavigationProperty.cs (2)

160System.Diagnostics.Debug.Assert(_fromEnd != null && _toEnd != null, 196Debug.Assert(_unresolvedRelationshipName == null, string.Format(CultureInfo.CurrentCulture, "{0} is already defined", reader.Name));

System\Data\EntityModel\SchemaObjectModel\Parameter.cs (3)

200Debug.Assert(typeModifier == TypeModifier.None, string.Format(CultureInfo.CurrentCulture, "Type is not valid for property {0}: {1}. The modifier for the type cannot be used in this context.", FQName, reader.Value)); 373Debug.Assert(Schema.DataModel == SchemaDataModelOption.ProviderDataModel || 379Debug.Assert(_typeSubElement == null, "Unexpected type subelement inside <Parameter> element.");

System\Data\EntityModel\SchemaObjectModel\ReferenceSchema.cs (2)

132Debug.Assert(String.IsNullOrEmpty(NamespaceName), "Alias must be set only once"); 144Debug.Assert(String.IsNullOrEmpty(Alias), "Alias must be set only once");

System\Data\EntityModel\SchemaObjectModel\ReferentialConstraint.cs (2)

78Debug.Assert(_principalRole.RoleProperties.Count != 0, "There should be some ref properties in Principal Role"); 79Debug.Assert(_dependentRole.RoleProperties.Count != 0, "There should be some ref properties in Dependent Role");

System\Data\EntityModel\SchemaObjectModel\ReferentialConstraintRoleElement.cs (2)

104Debug.Assert(!String.IsNullOrEmpty(this.Name), "RoleName should never be empty"); 131Debug.Assert(_roleProperties != null, "xsd should have verified that there should be atleast one property ref element in referential role element");

System\Data\EntityModel\SchemaObjectModel\RelationshipEndCollection.cs (4)

51Debug.Assert(end != null, "end parameter is null"); 54Debug.Assert(endElement != null, "end is not a SchemaElement"); 102Debug.Assert(end != null, "end parameter is null"); 130Debug.Assert(end != null, "end parameter is null");

System\Data\EntityModel\SchemaObjectModel\ReturnType.cs (7)

143Debug.Assert(_typeSubElement != null, "Nested type expected."); 171Debug.Assert(typeModifier == TypeModifier.None, string.Format(CultureInfo.CurrentCulture, "Type is not valid for property {0}: {1}. The modifier for the type cannot be used in this context.", FQName, reader.Value)); 281Debug.Assert(!this.ParentElement.IsFunctionImport, "FunctionImports can't have sub elements in their return types, so we should NEVER see them here"); 304Debug.Assert(Schema.DataModel == SchemaDataModelOption.ProviderDataModel || 330Debug.Assert(Schema.DataModel == SchemaDataModelOption.ProviderDataModel, "Unexpected data model"); 362Debug.Assert(collection != null, "Can't find <CollectionType> inside TVF <ReturnType> element"); 366Debug.Assert(row != null, "Can't find <RowType> inside TVF <ReturnType><CollectionType> element");

System\Data\EntityModel\SchemaObjectModel\RowTypeElement.cs (1)

112Debug.Assert(Schema.DataModel == SchemaDataModelOption.ProviderDataModel, "Only DataModel == SchemaDataModelOption.ProviderDataModel is expected");

System\Data\EntityModel\SchemaObjectModel\RowTypePropertyElement.cs (2)

79Debug.Assert(typeModifier == TypeModifier.None, string.Format(CultureInfo.CurrentCulture, "Type is not valid for property {0}: {1}. The modifier for the type cannot be used in this context.", FQName, reader.Value)); 184Debug.Assert(_typeSubElement != null, "For attributes typeusage should have been resolved");

System\Data\EntityModel\SchemaObjectModel\Schema.cs (13)

65Debug.Assert(schemaManager != null, "SchemaManager parameter should never be null"); 133Debug.Assert(sourceReader != null, "sourceReader parameter is null"); 192Debug.Assert(this.SchemaXmlNamespace == XmlConstants.ModelNamespace_3, "Unknown namespace in CSDL"); 208Debug.Assert(this.SchemaXmlNamespace == XmlConstants.TargetNamespace_3, "Unknown namespace in SSDL"); 317Debug.Assert(this.SchemaVersion >= XmlConstants.EdmVersionForV2 || SchemaVersion == XmlConstants.UndefinedVersion, "Have you added a new Edm Version?"); 698Debug.Assert(DataModel == SchemaDataModelOption.ProviderManifestModel, "Did you add a new option?"); 878Debug.Assert(type.Namespace != this.Namespace, "Using element is not allowed in the schema of ssdl and provider manifest"); 1178Debug.Assert(error != AddErrorKind.MissingNameError, "Function identity can never be null while adding global functions"); 1223Debug.Assert(dataModel == SchemaDataModelOption.ProviderManifestModel, "Unknown SchemaDataModelOption did you add one?"); 1237Debug.Assert(namespaceNames.Count > 0, "Unknown Datamodel"); 1247Debug.Assert(schemaResourceMap.ContainsKey(namespaceName), "the namespace name is not one we have a schema set for"); 1276Debug.Assert(resourceName != null, "resourceName cannot be null"); 1285Debug.Assert(resourceStream != null, string.Format(CultureInfo.CurrentCulture, "Unable to load the resource {0} from assembly resources.", resourceName));

System\Data\EntityModel\SchemaObjectModel\SchemaElement.cs (6)

415Debug.Assert(string.IsNullOrEmpty(field), string.Format(CultureInfo.CurrentCulture, "{0} is already defined", reader.Name)); 434Debug.Assert(string.IsNullOrEmpty(field), string.Format(CultureInfo.CurrentCulture, "{0} is already defined", reader.Name)); 674Debug.Assert( 682Debug.Assert( 706Debug.Assert(reader.NodeType == XmlNodeType.Attribute, "called an attribute function when not on an attribute"); 801Debug.Assert(reader.SchemaInfo == null ||

System\Data\EntityModel\SchemaObjectModel\SchemaElementLookUpTable.cs (5)

124Debug.Assert(type != null, "type parameter is null"); 146Debug.Assert(type != null, "type parameter is null"); 147Debug.Assert(null != duplicateKeyErrorFormat, "duplicateKeyErrorFormat cannot be null"); 167Debug.Assert(error == AddErrorKind.Succeeded, "Invalid error encountered"); 194Debug.Assert(!String.IsNullOrEmpty(unnormalizedKey), "unnormalizedKey parameter is null or empty");

System\Data\EntityModel\SchemaObjectModel\SchemaElementLookUpTableEnumerator.cs (2)

38Debug.Assert(data != null, "data parameter is null"); 39Debug.Assert(keysInOrder != null, "keysInOrder parameter is null");

System\Data\EntityModel\SchemaObjectModel\SchemaEnumMember.cs (3)

49Debug.Assert(value != null, "value != null"); 62Debug.Assert(reader != null, "reader != null"); 79Debug.Assert(reader != null, "reader != null");

System\Data\EntityModel\SchemaObjectModel\SchemaEnumType.cs (5)

73Debug.Assert(_underlyingType != null, "The type has not been resolved yet"); 96Debug.Assert(reader != null, "reader != null"); 132Debug.Assert(reader != null, "reader != null"); 159Debug.Assert(reader != null, "reader != null"); 229Debug.Assert(!_enumMembers.Any(m => !m.Value.HasValue), "member values should have been fixed up already.");

System\Data\EntityModel\SchemaObjectModel\SchemaLookupTable.cs (3)

50Debug.Assert(usingElement != null, "usingElement parameter is null"); 90Debug.Assert(!String.IsNullOrEmpty(alias), "alias must never be null"); 124Debug.Assert(_definingSchema.ProviderManifest != null, "Since we don't allow using elements in provider manifest, provider manifest can never be null");

System\Data\EntityModel\SchemaObjectModel\SchemaManager.cs (2)

87Debug.Assert(errors.Count != 0, "There must be some error encountered"); 297Debug.Assert(schema.DataModel == _dataModel, "DataModel must match");

System\Data\EntityModel\SchemaObjectModel\StructuredProperty.cs (1)

212Debug.Assert(Schema.SchemaVersion != XmlConstants.EdmVersionForV1,

System\Data\EntityModel\SchemaObjectModel\StructuredType.cs (4)

92Debug.Assert((BaseType == null && _unresolvedBaseType == null) || 210Debug.Assert(newMember != null, "newMember parameter is null"); 246Debug.Assert(definingMember == null, "we allow the scenario that members can have same name but different cases"); 371Debug.Assert(UnresolvedBaseType == null, string.Format(CultureInfo.CurrentCulture, "{0} is already defined", reader.Name));

System\Data\EntityModel\SchemaObjectModel\TypeUsageBuilder.cs (3)

374Debug.Assert(primitiveType.PrimitiveTypeKind == PrimitiveTypeKind.Decimal, "Expected decimal type"); 464Debug.Assert(primitiveType.PrimitiveTypeKind == PrimitiveTypeKind.Binary || 495Debug.Assert(Helper.IsSpatialType(primitiveType), "Expected spatial type");

System\Data\EntityModel\SchemaObjectModel\Utils.cs (18)

System\Data\EntityModel\SchemaObjectModel\ValidationHelper.cs (1)

46Debug.Assert(!(type is SchemaEnumType), "Note that enums should have already been handled.");

System\Data\EntityModel\SchemaObjectModel\XmlSchemaResource.cs (8)

21Debug.Assert(!string.IsNullOrEmpty(namespaceUri), "namespaceUri is null or empty"); 22Debug.Assert(!string.IsNullOrEmpty(resourceName), "resourceName is null or empty"); 23Debug.Assert(importedSchemas != null, "importedSchemas is null"); 30Debug.Assert(!string.IsNullOrEmpty(namespaceUri), "namespaceUri is null or empty"); 31Debug.Assert(!string.IsNullOrEmpty(resourceName), "resourceName is null or empty"); 72Debug.Assert(XmlConstants.SchemaVersionLatest == XmlConstants.StoreVersionForV3, "Did you add a new schema version"); 99Debug.Assert(XmlConstants.SchemaVersionLatest == XmlConstants.EdmVersionForV3, "Did you add a new schema version"); 136Debug.Assert(XmlConstants.SchemaVersionLatest == XmlConstants.EdmVersionForV3, "Did you add a new schema version");

System\Data\EntitySqlException.cs (2)

203Debug.Assert(errorPosition > -1, "position in input stream cannot be < 0"); 204Debug.Assert(errorPosition <= commandText.Length, "position in input stream cannot be greater than query text size");

System\Data\Mapping\DefaultObjectMappingItemCollection.cs (22)

System\Data\Mapping\FunctionImportMapping.cs (4)

173Debug.Assert(structuralTypeMappings.First() is FunctionImportComplexTypeMapping, "only two types can have renames, complexType and entityType"); 176Debug.Assert(complexTypeMappings.Count() == 1, "how come there are more than 1, complex type cannot derive from other complex type"); 525Debug.Assert(columnConditions.Count == parent.DiscriminatorColumns.Count, 527Debug.Assert(impliedEntityTypes.Count == parent.MappedEntityTypes.Count,

System\Data\Mapping\FunctionImportMapping.ReturnTypeRenameMapping.cs (2)

214Debug.Assert(type is StructuralType, "we can only rename structural type"); 271Debug.Assert(null != lowestParent, "We should have the lowest parent");

System\Data\Mapping\FunctionImportMappingComposable.cs (35)

41Debug.Assert(functionImport.IsComposableAttribute, "functionImport.IsComposableAttribute"); 42Debug.Assert(targetFunction.IsComposableAttribute, "targetFunction.IsComposableAttribute"); 43Debug.Assert(functionImport.EntitySet == null || structuralTypeMappings != null, "Function import returning entities must have structuralTypeMappings."); 44Debug.Assert(structuralTypeMappings == null || structuralTypeMappings.Count > 0, "Non-null structuralTypeMappings must not be empty."); 46Debug.Assert( 50Debug.Assert(functionImport.EntitySet == null || targetFunctionKeys != null, "Keys must be inferred for a function import returning entities."); 51Debug.Assert(targetFunctionKeys == null || targetFunctionKeys.Length > 0, "Keys must be null or non-empty."); 105Debug.Assert(tree != null, "tree != null"); 112Debug.Assert(rootProjectOp.Outputs.Count == 1, "rootProjectOp.Outputs.Count == 1"); 125Debug.Assert(TypeSemantics.IsPromotableTo(functionViewType, this.FunctionImport.ReturnParameter.TypeUsage), "Mapping expression result type must be promotable to the c-space function return type."); 142Debug.Assert(m_internalTreeNode != null, "m_internalTreeNode != null"); 145Debug.Assert(m_commandParameters.Length == targetIqtArguments.Count, "m_commandParameters.Length == targetIqtArguments.Count"); 162Debug.Assert(TypeSemantics.IsPromotableTo(argumentNode.Op.Type, commandParam.ResultType), "Argument type must be promotable to parameter type."); 214Debug.Assert(errors != null, "errors != null"); 220Debug.Assert(this.TargetFunction != null, "this.TargetFunction != null"); 228Debug.Assert(queryExpression == null || 235Debug.Assert(queryExpression == null || 252Debug.Assert(this.FunctionImport.Parameters.Count == m_commandParameters.Length, "this.FunctionImport.Parameters.Count == m_commandParameters.Length"); 253Debug.Assert(this.TargetFunction.Parameters.Count == m_commandParameters.Length, "this.TargetFunction.Parameters.Count == m_commandParameters.Length"); 256Debug.Assert(this.FunctionImport.Parameters.Contains(targetParameter.Name), "this.FunctionImport.Parameters.Contains(targetParameter.Name)"); 273Debug.Assert(m_structuralTypeMappings != null && m_structuralTypeMappings.Count > 0, "m_structuralTypeMappings != null && m_structuralTypeMappings.Count > 0"); 310Debug.Assert(m_structuralTypeMappings.All(m => m.Item2.Count > 0), "In multi-type mapping each type must have conditions."); 333Debug.Assert(structuralTypeMappingViews.Count == structuralTypePredicates.Count, "structuralTypeMappingViews.Count == structuralTypePredicates.Count"); 336Debug.Assert(errors.Count > 0, "errors.Count > 0"); 350Debug.Assert(discriminatorMap != null, "discriminatorMap == null after it has been created"); 361Debug.Assert(properties.Count == propertyMappings.Count, "properties.Count == propertyMappings.Count"); 366Debug.Assert(properties[i].EdmEquals(propertyMapping.EdmProperty), "properties[i].EdmEquals(propertyMapping.EdmProperty)"); 375Debug.Assert(errors.Count > 0, "errors.Count > 0"); 387Debug.Assert(conditions.Count > 0, "conditions.Count > 0"); 394Debug.Assert(condition.EdmProperty == null, "C-side conditions are not supported in function mappings."); 409Debug.Assert(mapping is StorageScalarPropertyMapping, "Complex property mapping is not supported in function imports."); 426Debug.Assert(row.ResultType.EdmType.BuiltInTypeKind == BuiltInTypeKind.RowType, "Input type is expected to be a row type."); 428Debug.Assert(rowType.Properties.Contains(column.Name), "Column name must be resolvable in the TVF result type."); 444Debug.Assert(TypeSemantics.IsCollectionType(queryExpression.ResultType), "Store function must be TVF (collection expected)."); 446Debug.Assert(TypeSemantics.IsRowType(collectionType.TypeUsage), "Store function must be TVF (collection of rows expected).");

System\Data\Mapping\FunctionImportMappingNonComposable.cs (5)

35Debug.Assert(!functionImport.IsComposableAttribute, "!functionImport.IsComposableAttribute"); 36Debug.Assert(!targetFunction.IsComposableAttribute, "!targetFunction.IsComposableAttribute"); 71Debug.Assert(resultSetIndex >= 0, "resultSetIndex >= 0"); 74Debug.Assert(this.ResultMappings.Count == 1, "this.ResultMappings.Count == 1"); 186Debug.Assert(null != structuralType, "this method must be called only for entity/complextype reader function imports");

System\Data\Mapping\MetadataMappingHasherVisitor.cs (4)

42Debug.Assert(storageEntityContainerMapping != null, "storageEntityContainerMapping cannot be null!"); 45Debug.Assert(m_MappingVersion == storageEntityContainerMapping.StorageMappingItemCollection.MappingVersion, "the original version and the mapping collection version are not the same"); 773Debug.Assert(instanceIndex >= 0, "referencing index should not be less than 0"); 826Debug.Assert(storageEntityContainerMapping != null, "storageEntityContainerMapping is null!");

System\Data\Mapping\MetadataMappingHasherVisitor.HashSourceBuilder.cs (3)

75Debug.Assert(this._indent > 0, "Indent and unindent should be paired"); 112Debug.Assert(startingBufferSize > 0, "should be a non zero positive integer"); 163Debug.Assert(start == byteCount, "Did we use a different calculation for these?");

System\Data\Mapping\ObjectMemberMapping.cs (1)

30System.Diagnostics.Debug.Assert(edmMember.BuiltInTypeKind == clrMember.BuiltInTypeKind, "BuiltInTypeKind must be the same");

System\Data\Mapping\ObjectTypeMapping.cs (3)

28Debug.Assert(clrType.BuiltInTypeKind == cdmType.BuiltInTypeKind, "BuiltInTypeKind must be the same for both types"); 131Debug.Assert(memberMapping.ClrMember.Name == memberMapping.EdmMember.Name, 136Debug.Assert(!Type.ReferenceEquals(m_memberMapping, EmptyMemberMapping),

System\Data\Mapping\StorageConditionPropertyMapping.cs (4)

63Debug.Assert((cdmMember != null) || (columnMember != null), "Both CDM and Column Members can not be specified for Condition Mapping"); 64Debug.Assert((cdmMember == null) || (columnMember == null), "Either CDM or Column Members has to be specified for Condition Mapping"); 65Debug.Assert((isNull.HasValue) || (value != null), "Both Value and IsNull can not be specified on Condition Mapping"); 66Debug.Assert(!(isNull.HasValue) || (value == null), "Either Value or IsNull has to be specified on Condition Mapping");

System\Data\Mapping\StorageEntitySetMapping.cs (3)

143Debug.Assert(null != modificationFunctionMapping, "modification function mapping must not be null"); 144Debug.Assert(modificationFunctionMapping.EntityType.Equals(this.Set.ElementType) || 148Debug.Assert(!existingMapping.EntityType.Equals(modificationFunctionMapping.EntityType),

System\Data\Mapping\StorageMappingFragment.cs (2)

69Debug.Assert(tableExtent != null, "Table should not be null when constructing a Mapping Fragment"); 70Debug.Assert(typeMapping != null, "TypeMapping should not be null when constructing a Mapping Fragment");

System\Data\Mapping\StorageMappingItemCollection.cs (20)

417Debug.Assert(2088 == (int)StorageMappingErrorCode.MappingAllQueryViewAtCompileTime, "Please change the ERRORCODE_MAPPINGALLQUERYVIEWATCOMPILETIME value as well"); 456Debug.Assert(entitySet != null, "entitySet != null"); 457Debug.Assert(entityType != null, "entityType != null"); 473Debug.Assert(entitySet != null, "entitySet != null"); 474Debug.Assert(entityType != null, "entityType != null"); 487Debug.Assert(storageTypeMapping is StorageEntityTypeMapping, "StorageEntityTypeMapping expected."); 506Debug.Assert(interestingMembers != null, "interestingMembers must never be null."); 518Debug.Assert(associationTypeMapping != null, "entityTypeMapping != null"); 519Debug.Assert(interestingMembers != null, "interestingMembers != null"); 539Debug.Assert(entityTypeMapping != null, "entityTypeMapping != null"); 540Debug.Assert(interestingMembers != null, "interestingMembers != null"); 548Debug.Assert(!(propertyMapping is StorageEndPropertyMapping), "association mapping properties should be handled elsewhere."); 550Debug.Assert(scalarPropMapping != null || 600Debug.Assert(complexMapping != null, "complexMapping != null"); 607Debug.Assert(childScalarPropertyMapping != null || 655Debug.Assert(functionMappings != null && functionMappings.UpdateFunctionMapping != null, "Expected function mapping fragment with non-null update function mapping"); 656Debug.Assert(interestingMembers != null, "interestingMembers != null"); 671Debug.Assert( 737Debug.Assert(m_memberMappings.Count == 0, "Assumption: This method is called only once, and from the constructor because m_extentMappingViews is not thread safe."); 894Debug.Assert(edmItemCollection != null && storeItemCollection != null && errorCollection != null, "The parameters must not be null in CheckForDuplicateItems");

System\Data\Mapping\StorageMappingItemCollection.ViewDictionary.cs (6)

117Debug.Assert(extentMappingViews.Count > 0, "view should be generated at this point"); 175Debug.Assert(!entityContainerMap.IsEmpty, "There are no entity set maps"); 192Debug.Assert(extentMappingViews.AllValues.Count() == 1, "Viewgen should have produced only one view"); 289Debug.Assert(aSet.ElementType.ReferentialConstraints.Count == 1, "aSet.ElementType.ReferentialConstraints.Count == 1"); 386Debug.Assert(viewContainer != null, "Should be able to create the type"); 471Debug.Assert(mappingCollection != null,"Must have Mapping Collection in the Metadataworkspace");

System\Data\Mapping\StorageMappingItemLoader.cs (27)

129Debug.Assert(m_currentNamespaceUri == StorageMslConstructs.NamespaceUriV3, "Did you add a new Namespace?"); 1511Debug.Assert(false, "XSD validation should ensure this"); 1596Debug.Assert(sTypeTvfElementType == null, "sTypeTvfElementType == null"); 1602Debug.Assert(functionImport.ReturnParameters.Count == 1, "functionImport.ReturnParameters.Count == 1 for a composable function import."); 1626Debug.Assert(TypeSemantics.IsScalarType(resultType), "TypeSemantics.IsScalarType(resultType)"); 1627Debug.Assert(typeMappings.Count == 0, "typeMappings.Count == 0"); 1646Debug.Assert(mapping != null, "mapping != null"); 1778Debug.Assert(importType != null, "Function import parameters must be primitive."); 1888Debug.Assert(entitySet == null, "entitySet == null for complex type mapping in function imports."); 2003Debug.Assert(null != columnRenameMappings, "columnRenameMappings cannot be null"); 2004Debug.Assert(null != nav, "nav cannot be null"); 2005Debug.Assert(null != currentTypes, "currentTypes cannot be null"); 2114Debug.Assert(resultType.BuiltInTypeKind == BuiltInTypeKind.ComplexType, "resultType.BuiltInTypeKind == BuiltInTypeKind.ComplexType"); 2202Debug.Assert(structuralTypeMappings.Count > 0, "Function import returning entities must have non-empty structuralTypeMappings."); 2218Debug.Assert(keys.Length == currentKeys.Length, "All subtypes must have the same number of keys."); 2385Debug.Assert(condition.ConditionValue == ValueCondition.IsNotNull, "Only IsNull or IsNotNull condition values are expected."); 2392Debug.Assert(cTypeColumn != null, "cTypeColumn != null"); 2393Debug.Assert(Helper.IsPrimitiveType(cTypeColumn.TypeUsage.EdmType), "S-space columns are expected to be of a primitive type."); 2395Debug.Assert(cPrimitiveType.ClrEquivalentType != null, "Scalar Types should have associated clr type"); 2396Debug.Assert(condition is FunctionImportEntityTypeMappingConditionValue, "Non-sentinel condition is expected to be of type FunctionImportEntityTypeMappingConditionValue."); 2485Debug.Assert(cTypeTvfElementType.Properties.Contains(columnName), "cTypeTvfElementType.Properties.Contains(columnName)"); 2525Debug.Assert(errorFound || 2869Debug.Assert(columnName != null, "XSD validation should have caught this"); 3271Debug.Assert(clrMemberType != null, "Scalar Types should have associated clr type"); 3597Debug.Assert( 3600Debug.Assert(Helper.IsPrimitiveType(columnMember.TypeUsage.EdmType), "s-space column type must be primitive"); 4446Debug.Assert(typeUsage != null, "typeUsage != null");

System\Data\Mapping\StorageModificationFunctionMapping.cs (1)

303Debug.Assert(2 == this.Members.Count, "Association bindings must always consist of the end and the key");

System\Data\Mapping\StorageScalarPropertyMapping.cs (2)

59Debug.Assert( 62Debug.Assert(Helper.IsPrimitiveType(columnMember.TypeUsage.EdmType), "StorageScalarPropertyMapping must only map primitive types");

System\Data\Mapping\StorageSetMapping.cs (1)

232Debug.Assert(!m_typeSpecificQueryViews.ContainsKey(key), "Query View already present for the given Key");

System\Data\Mapping\Update\Internal\CompositeKey.cs (4)

36Debug.Assert(null != constants, "key values must be given"); 58Debug.Assert(null != other && other.KeyComponents.Length == this.KeyComponents.Length, "expected a compatible CompositeKey"); 90Debug.Assert(null != left.KeyComponents && null != right.KeyComponents, 145Debug.Assert(null != keyComponent && null != keyComponent,

System\Data\Mapping\Update\Internal\DynamicUpdateCommand.cs (3)

72Debug.Assert(op == ModificationOperator.Insert || op == ModificationOperator.Update, "only inserts and updates have setters"); 207Debug.Assert(originalTree.CommandTreeKind == DbCommandTreeKind.Insert || originalTree.CommandTreeKind == DbCommandTreeKind.Update, "Set clauses specified for a modification tree that is not an update or insert tree?"); 309Debug.Assert(!object.ReferenceEquals(this, otherCommand), "caller is supposed to ensure otherCommand is different reference");

System\Data\Mapping\Update\Internal\ExtractedStateEntry.cs (1)

30Debug.Assert(null != stateEntry, "stateEntry must not be null");

System\Data\Mapping\Update\Internal\ExtractorMetadata.cs (5)

143Debug.Assert(null != (object)key, "entities must have keys, and only entity members are marked IsKeyMember by " + 164Debug.Assert(record.GetName(ordinal) == memberInformation.Member.Name, "expect record to present properties in metadata order"); 222Debug.Assert(entityEntry.State == EntityState.Added, 231Debug.Assert(keyValue != null, "keyValue should've been retrieved."); 374Debug.Assert(entityKeyOrdinal.HasValue ==

System\Data\Mapping\Update\Internal\FunctionMappingTranslator.cs (3)

67Debug.Assert(null != setMapping && null != setMapping.ModificationFunctionMappings && 150Debug.Assert(-1 != toOrdinal, "to end of relationship doesn't exist in record"); 335Debug.Assert(2 == parameterBinding.MemberPath.Members.Count, "relationship parameter binding member " +

System\Data\Mapping\Update\Internal\FunctionUpdateCommand.cs (2)

162Debug.Assert(rowsAffectedParameter.Mode == ParameterMode.Out || rowsAffectedParameter.Mode == ParameterMode.InOut, 363Debug.Assert(!object.ReferenceEquals(this, otherCommand), "caller should ensure other command is different");

System\Data\Mapping\Update\Internal\KeyManager.cs (2)

87Debug.Assert(PropagatorResult.NullIdentifier != owner.Identifier, "invalid operation for a " + 465Debug.Assert(!_nodeIds.Contains(nodeId), "don't add existing node to partition");

System\Data\Mapping\Update\Internal\Propagator.cs (1)

254Debug.Assert(null != node.Projection, "CQT validates DbProjectExpression.Projection property");

System\Data\Mapping\Update\Internal\Propagator.Evaluator.cs (10)

System\Data\Mapping\Update\Internal\Propagator.ExtentPlaceholderCreator.cs (1)

163Debug.Assert(null != associationSet, "Caller must verify parameters are not null");

System\Data\Mapping\Update\Internal\Propagator.JoinPropagator.cs (3)

64Debug.Assert(DbExpressionKind.LeftOuterJoin == node.ExpressionKind || DbExpressionKind.InnerJoin == node.ExpressionKind, "(Update/JoinPropagagtor/JoinEvaluator) " + 239Debug.Assert((((joinInsert | joinDelete | lojInsert | lojDelete) & 244Debug.Assert(((joinInsert ^ joinDelete) & (Ops.LeftUnknown | Ops.RightUnknown)) == Ops.Nothing &&

System\Data\Mapping\Update\Internal\Propagator.JoinPropagator.JoinPredicateVisitor.cs (1)

93Debug.Assert(leftKeySelectors.Count == rightKeySelectors.Count,

System\Data\Mapping\Update\Internal\RelationshipConstraintValidator.cs (4)

77Debug.Assert(null != (object)stateEntry.EntityKey, "entity state entry must have an entity key"); 411Debug.Assert(null != other, "other must not be null"); 412Debug.Assert(this.Equals(other), "other must be another instance of the same relationship target"); 413Debug.Assert(Object.ReferenceEquals(other._equivalenceSetLinkedListNext, other), "other must not be part of an equivalence set yet");

System\Data\Mapping\Update\Internal\TableChangeProcessor.cs (2)

95Debug.Assert(keyOrdinals[keyMemberIndex] >= 0 && keyOrdinals[keyMemberIndex] < members.Count, 124Debug.Assert(hasDelete || hasInsert, "(update/TableChangeProcessor) m_keys must not contain a value " +

System\Data\Mapping\Update\Internal\UpdateCommand.cs (3)

145Debug.Assert(2 == record.FieldCount, "non-binary relationship?"); 173Debug.Assert(!owner.StateEntry.IsRelationship, "owner must not be a relationship"); 219Debug.Assert(null != other, "comparing to null UpdateCommand");

System\Data\Mapping\Update\Internal\UpdateCommandOrderer.cs (1)

118Debug.Assert(constraintFound && null != target && null != source, "relationship set must have at least one constraint");

System\Data\Mapping\Update\Internal\UpdateCompiler.cs (6)

300Debug.Assert(originalRow != null, "Updated records should have a original row"); 302Debug.Assert(originalPropertyResult.IsSimple, "Server Gen property that is not primitive?"); 303Debug.Assert(propertyResult.IsSimple, "Server Gen property that is not primitive?"); 403Debug.Assert(null != predicate, "some predicate term must exist"); 438Debug.Assert(Helper.IsPrimitiveType(property.TypeUsage.EdmType), "Properties in SSpace should be primitive."); 464Debug.Assert(Nullable.GetUnderlyingType(principalValue.GetType()) == null, "Unexpected nullable type.");

System\Data\Mapping\Update\Internal\UpdateTranslator.cs (11)

System\Data\Mapping\Update\Internal\ViewLoader.cs (1)

35Debug.Assert(null != mappingCollection, "mapping collection required");

System\Data\Mapping\ViewGeneration\BasicViewGenerator.cs (5)

37Debug.Assert(usedCells.Count > 0, "No used cells"); 136Debug.Assert(extent != null, "Each cell must have a right extent"); 176Debug.Assert(rootNode.OpType == CellTreeOpType.FOJ, "So far, we have FOJs only"); 350Debug.Assert(extentMap.KeyValuePairs.All(m => m.Value.Count == 1), "extentMap must map to single nodes only."); 487Debug.Assert(opTypeToIsolate == CellTreeOpType.IJ || opTypeToIsolate == CellTreeOpType.LOJ

System\Data\Mapping\ViewGeneration\CellCreator.cs (5)

280Debug.Assert(entityTypeMap != null || 300Debug.Assert(extent != null, "Extent map for a null extent or type of extentMap.Exent " + 349Debug.Assert((fragmentInfo != null), "CSMappingFragment should support Line Info"); 378Debug.Assert(scalarPropMap != null || 385Debug.Assert(scalarPropMap.ColumnProperty != null, "ColumnMember for a Scalar Property can not be null");

System\Data\Mapping\ViewGeneration\CellTreeSimplifier.cs (8)

62Debug.Assert(rootNode.OpType == CellTreeOpType.LOJ || rootNode.OpType == CellTreeOpType.IJ || 72Debug.Assert(children.Count > 0, "OpCellTreeNode has no children?"); 238Debug.Assert(opNode.OpType != CellTreeOpType.Leaf, "Leaf type for op cell node?"); 366Debug.Assert(leaf1 != null, "Merge only possible on leaf nodes (1)"); 367Debug.Assert(leaf2 != null, "Merge only possible on leaf nodes (2)"); 466Debug.Assert(g1 == null && g2 == null, "IJ does not affect g1 and g2"); 475Debug.Assert(g1 == null, "LOJ does not affect g1"); 499Debug.Assert(g1 == null, "LASJ does not affect g1");

System\Data\Mapping\ViewGeneration\ConfigViewGenerator.cs (1)

160Debug.Assert(m_singlePerfOp == perfType, "Started op for different activity " + m_singlePerfOp + " -- not " + perfType);

System\Data\Mapping\ViewGeneration\CqlGeneration\AliasedSlot.cs (2)

32Debug.Assert(block != null && slot != null, "Null input to QualifiedSlot constructor"); 91Debug.Assert(blockAlias == null || m_block.CqlAlias == blockAlias, "QualifiedSlot: blockAlias mismatch");

System\Data\Mapping\ViewGeneration\CqlGeneration\BooleanProjectedSlot.cs (1)

34Debug.Assert(!(expr.AsLiteral is CellIdBoolean) ||

System\Data\Mapping\ViewGeneration\CqlGeneration\CaseCqlBlock.cs (4)

51Debug.Assert(m_caseSlotInfo.OutputMember != null, "We only construct member slots, not boolean slots."); 54Debug.Assert(Children.Count == 1, "CaseCqlBlock can have exactly one child."); 78Debug.Assert(m_caseSlotInfo.OutputMember != null, "We only construct real slots not boolean slots"); 81Debug.Assert(Children.Count == 1, "CaseCqlBlock can have exactly one child.");

System\Data\Mapping\ViewGeneration\CqlGeneration\CqlBlock.cs (8)

118Debug.Assert(this.IsProjected(slotNum), StringUtil.FormatInvariant("Slot {0} that is to be qualified with the block alias is not projected in this block", slotNum)); 125Debug.Assert(slotNum < m_slots.Count, "Slotnum too high"); 131Debug.Assert(slotNum < m_slots.Count, "Slotnum too high"); 140Debug.Assert(slotNum < m_slots.Count, "Slotnum too high"); 193Debug.Assert(this.Slots.Where(slot => slot.IsRequiredByParent).Count() == 1, "Top level projection must project only one slot."); 209Debug.Assert(m_joinTreeContext == null, "Join tree context is already set."); 267Debug.Assert(parentQualifiers != null, "parentQualifiers != null"); 268Debug.Assert(leafQualifier != null, "leafQualifier != null");

System\Data\Mapping\ViewGeneration\CqlGeneration\SlotInfo.cs (2)

49Debug.Assert(false == m_isRequiredByParent || m_slotValue != null, "Required slots cannot be null"); 50Debug.Assert(m_slotValue is QualifiedSlot ||

System\Data\Mapping\ViewGeneration\CqlGeneration\UnionCqlBlock.cs (2)

37Debug.Assert(this.Children.Count > 0, "UnionCqlBlock: Children collection must not be empty"); 59Debug.Assert(this.Children.Count > 0, "UnionCqlBlock: Children collection must not be empty");

System\Data\Mapping\ViewGeneration\CqlGenerator.cs (8)

113Debug.Assert(query != null, "Null CQT generated for query/update view."); 131Debug.Assert(requiredSlots.Length == TotalSlots, "Wrong number of requiredSlots"); 225Debug.Assert(thisRequiredSlots.Length == parentRequiredSlots.Length && 288Debug.Assert(isRequiredByParent, "Case result not needed by parent"); 349Debug.Assert(true == m_caseStatements.ContainsKey(caseMemberPath), "Constructing case for regular field?"); 350Debug.Assert(requiredSlots.Length == TotalSlots, "Invalid array size for populating required slots"); 409Debug.Assert(refType != null, "What other non scalars do we have? Relation end must be a reference type"); 442Debug.Assert(index != -1, "Couldn't locate " + fullMember.ToString() + " in m_projectedSlotMap");

System\Data\Mapping\ViewGeneration\DiscriminatorMap.cs (1)

198Debug.Assert(entityType.Properties.Count == constructor.Arguments.Count, "invalid new instance");

System\Data\Mapping\ViewGeneration\GeneratedView.cs (11)

44Debug.Assert(!config.GenerateEsql || !String.IsNullOrEmpty(eSQL), "eSQL must be specified"); 56Debug.Assert(discriminatorMap != null, "discriminatorMap == null after it has been created"); 105Debug.Assert(commandTree != null, "commandTree not set after parsing the view"); 148Debug.Assert(commandTree != null || !String.IsNullOrEmpty(eSQL), "commandTree or eSQL must be specified"); 190Debug.Assert(!String.IsNullOrEmpty(m_eSQL), "m_eSQL must be initialized"); 195Debug.Assert(m_commandTree != null, "m_commandTree not set after parsing the view"); 208Debug.Assert(m_extent.EntityContainer.DataSpace == DataSpace.CSpace, "Internal Tree should be asked only for query view"); 221Debug.Assert(m_internalTreeNode != null, "m_internalTreeNode != null"); 255Debug.Assert(!String.IsNullOrEmpty(eSQL), "eSQL query is not specified"); 268Debug.Assert(discriminatorMap != null, "discriminatorMap == null after it has been created"); 290Debug.Assert(commandTree != null || parserException != null, "Either commandTree or parserException is expected.");

System\Data\Mapping\ViewGeneration\QueryRewriting\QueryRewriter.cs (6)

446Debug.Assert(nonConditionalAttributes.Count > 0, "Must have caught key-only case earlier"); 604Debug.Assert(_context.ViewTarget == ViewTarget.UpdateView, "Used for update views only"); 611Debug.Assert(unionCaseRewriting != null, "No union of rewritings for case statements"); 831Debug.Assert(toFill.Query.Attributes.Count > 0, "Query has no attributes?"); 836Debug.Assert(!found || rewriting.GetNamedQueries().All(q => q != TrueViewSurrogate.Query), 924Debug.Assert(toFill.Query.Attributes.Count == 0, "This method is used for attribute-less queries only");

System\Data\Mapping\ViewGeneration\QueryRewriting\RewritingValidator.cs (3)

70Debug.Assert(complementSQueryTreeForCondition != null, "Rewriting for S-side query is unsatisfiable"); 106Debug.Assert(plainSQueryTreeForCondition != null, "Rewriting for S-side query is unsatisfiable"); 296Debug.Assert(constant is ScalarConstant || constant.IsNull() || constant is NegatedConstant, "Invalid type of constant");

System\Data\Mapping\ViewGeneration\Structures\BoolExpression.cs (1)

426Debug.Assert(domainMap != null, "Member domain map is not set");

System\Data\Mapping\ViewGeneration\Structures\BoolExpressionVisitors.cs (5)

136Debug.Assert(result == isChildFinal, "All children must be final or non-final"); 350Debug.Assert(cqt != null, "AND must have at least one child"); 357Debug.Assert(cqt != null, "OR must have at least one child"); 581Debug.Assert(m_allowAllOperators, "Term should not be called when Nots are present in the expression"); 603Debug.Assert(m_allowAllOperators, "TermVisitor should not be called when Ors are present in the expression");

System\Data\Mapping\ViewGeneration\Structures\BoolLiteral.cs (1)

193Debug.Assert(range.Count == 1, "For BoolLiterals, there should be precisely one value - true or false");

System\Data\Mapping\ViewGeneration\Structures\CaseStatement.cs (10)

103Debug.Assert(!m_simplified, "Attempt to modify a simplified case statement"); 119Debug.Assert(m_memberPath.Equals(((MemberProjectedSlot)m_elseValue).MemberPath), "case statement slot (ELSE) must depend only on its own slot value"); 126Debug.Assert(m_memberPath.Equals(((MemberProjectedSlot)whenThen.Value).MemberPath), "case statement slot (THEN) must depend only on its own slot value"); 232Debug.Assert(this.ElseValue != null, "CASE statement with no WHEN/THENs must have ELSE."); 284Debug.Assert(elseValue != null, "CASE statement with no WHEN/THENs must have ELSE."); 292Debug.Assert(slot is MemberProjectedSlot || slot is QualifiedSlot || slot is ConstantProjectedSlot, 320Debug.Assert(slot is MemberProjectedSlot || slot is QualifiedSlot || slot is ConstantProjectedSlot, 342Debug.Assert(typeConstructor != null && typeConstructor.ResultType.EdmType.BuiltInTypeKind == BuiltInTypeKind.EntityType, 360Debug.Assert(constantSlot != null, "WITH RELATIONSHIP clauses should be specified for type constant slots only."); 362Debug.Assert(typeConstant != null, "WITH RELATIONSHIP clauses should be there for type constants only.");

System\Data\Mapping\ViewGeneration\Structures\Cell.cs (7)

45Debug.Assert(label != null, "Cell lacks label"); 50Debug.Assert(m_sQuery.NumProjectedSlots == m_cQuery.NumProjectedSlots, 181Debug.Assert(CQuery.NumProjectedSlots == SQuery.NumProjectedSlots, 187Debug.Assert(cSlot != null, "Has cell query been normalized?"); 188Debug.Assert(sSlot != null, "Has cell query been normalized?"); 191Debug.Assert(cSlot is MemberProjectedSlot, "cSlot is expected to be MemberProjectedSlot"); 192Debug.Assert(sSlot is MemberProjectedSlot, "sSlot is expected to be MemberProjectedSlot");

System\Data\Mapping\ViewGeneration\Structures\CellQuery.cs (17)

129Debug.Assert(extent != null, "JoinTreeRoot in cellquery must be an extent"); 173Debug.Assert(m_basicCellRelation != null, "BasicCellRelation must be created first"); 196Debug.Assert(slotNum < m_projectedSlots.Length, "Slot number too high"); 221Debug.Assert(slot != null, "All slots for this method must be JoinTreeSlots"); 233Debug.Assert(indexes.Count >= 1, "Each slot must have one index at least"); 300Debug.Assert(cSideSlotIndexes.Count > 1, "Method called when no duplicate mapping"); 375Debug.Assert(m_projectedSlots[slotNumber] == null, "Another attempt to plug in a default value"); 406Debug.Assert(slot != null, "All slots during cell normalization must field slots"); 410Debug.Assert(newSlotNum >= 0, "Field projected but not in projectedSlotMap"); 447Debug.Assert(projectedVar != null, "Projected slot must not be a constant"); 472Debug.Assert(entitySetKeys.Count == 1, "Currently, we only support primary keys"); 489Debug.Assert(endKeys.Count == 1, "Currently, we only support primary keys"); 600Debug.Assert(slotIndexes.Count == 1, "Expecting the path to be projected only once"); 647Debug.Assert(slotIndex == -1, "Should be projected only once"); 678Debug.Assert(restriction != null, "All bool literals must be OneOfConst at this point"); 733Debug.Assert(cellNum < numBoolVars, "Trying to set boolean with too high an index"); 763Debug.Assert(result != null, "Atom must be restriction");

System\Data\Mapping\ViewGeneration\Structures\CellTreeNodeVisitors.cs (4)

138Debug.Assert(flattenedChildren.Count >= 1, "node must have more than 1 child and be an OpCellTreeNode"); 145Debug.Assert(flattenedChildren.Count > 1, "Opnode has 0 children?"); 146Debug.Assert(node.OpType != CellTreeOpType.Leaf, "Wrong op type for operation node"); 192Debug.Assert(flattenedChildren.Count > 1, "node must have more than 1 child and be an OpCellTreeNode");

System\Data\Mapping\ViewGeneration\Structures\Constant.cs (5)

162Debug.Assert(outputMember.LeafEdmMember != null, "Constant can't correspond to an empty member path."); 173Debug.Assert(outputMember.LeafEdmMember != null, "Constant can't correspond to an empty path."); 186Debug.Assert(Object.ReferenceEquals(this, Instance), "this must be == Instance for NullConstant"); 253Debug.Assert(Object.ReferenceEquals(this, Instance), "this must be == Instance for NullConstant"); 324Debug.Assert(Object.ReferenceEquals(this, Instance), "this must be == Instance for NullConstant");

System\Data\Mapping\ViewGeneration\Structures\ConstantProjectedSlot.cs (1)

31Debug.Assert(value.IsNotNull() == false, "Cannot store NotNull in a slot - NotNull is only for conditions");

System\Data\Mapping\ViewGeneration\Structures\Domain.cs (8)

139Debug.Assert(Helper.AsPrimitive(type).PrimitiveTypeKind == PrimitiveTypeKind.Boolean, "Only boolean type has discrete domain."); 173Debug.Assert(domain != null, "Domain not set up for some type"); 320Debug.Assert(constElement as NegatedConstant == null, "Negated cell constant inside NegatedCellConstant"); 425Debug.Assert(cSlot != null, "Assuming constants are not projected"); 520Debug.Assert(result == null, "Multiple negated cell constants?"); 545Debug.Assert(domain1.m_possibleValues.SetEquals(domain2.m_possibleValues), "domains must be compatible"); 564Debug.Assert(negated == null, "m_possibleValues cannot contain negated constant"); 566Debug.Assert(m_domain.IsSubsetOf(AllPossibleValuesInternal),

System\Data\Mapping\ViewGeneration\Structures\ErrorLog.cs (2)

137Debug.Assert(m_sourceCells.Count > 0, "Error record must have at least one cell"); 188Debug.Assert(isFirst == false, "No cells");

System\Data\Mapping\ViewGeneration\Structures\LeafCellTreeNode.cs (4)

75Debug.Assert(m_rightFragmentQuery != null, "Unassigned right fragment query"); 133Debug.Assert(cellQuery.NumProjectedSlots + cellQuery.NumBoolVars == totalSlots, 136Debug.Assert(cellQuery.NumProjectedSlots == ProjectedSlotMap.Count, 234Debug.Assert(scalarPropertyMaps.Count() == 1, "Can't Map the same column multiple times in the same end");

System\Data\Mapping\ViewGeneration\Structures\LeftCellWrapper.cs (3)

166Debug.Assert(result != null, "Bad root value in join tree"); 282Debug.Assert(endMember != null, "Element in path before scalar path is not end property?"); 285Debug.Assert(result != null, "No end found for keyslots of table?");

System\Data\Mapping\ViewGeneration\Structures\MemberDomainMap.cs (1)

90Debug.Assert(condition is ScalarRestriction || condition is TypeRestriction,

System\Data\Mapping\ViewGeneration\Structures\MemberPath.cs (7)

501Debug.Assert(found == true, "We did not find the key property in a ref's element type - it cannot be in a subtype"); 502Debug.Assert(MetadataHelper.IsPartOfEntityTypeKey(member), "Member is expected to be a key property"); 512Debug.Assert(prevRefType == null, "We do not allow subtyping in key extraction from Refs"); 559Debug.Assert(keyAttributes.Any(), "No key attributes?"); 668Debug.Assert(assocSet != null && entitySet != null, 699Debug.Assert(assocPath0.Extent.Equals(assocSet) && assocPath1.Extent.Equals(assocSet), 752Debug.Assert(this.Extent is EntitySet, "path must be in the context of an entity set");

System\Data\Mapping\ViewGeneration\Structures\MemberProjectedSlot.cs (3)

147Debug.Assert(entitySet != null, "Prefix must have associated entity set"); 150Debug.Assert(keys.Count > 0, "No keys for entity?"); 151Debug.Assert(keys.Count == 1, "Currently, we only support primary keys");

System\Data\Mapping\ViewGeneration\Structures\MemberProjectionIndex.cs (7)

142Debug.Assert(boolIndex >= 0 && boolIndex < numBoolSlots, "No such boolean in this node"); 151Debug.Assert(slotNum < this.Count + numBoolSlots && slotNum >= this.Count, "No such boolean slot"); 160Debug.Assert(slotNum < this.Count + numBoolSlots, "No such slot in tree"); 169Debug.Assert(slotNum < this.Count + numBoolSlots, "Boolean slot does not exist in tree"); 191Debug.Assert(complexTypemember != null || 213Debug.Assert(possibleStructuralType != null, "Non-structural subtype?"); 245Debug.Assert(structuralMember.TypeUsage.EdmType is ComplexType ||

System\Data\Mapping\ViewGeneration\Structures\MemberRestriction.cs (4)

57Debug.Assert(m_domain.Count != 0, "If you want a boolean that evaluates to false, " + 230Debug.Assert(constants.Contains(constant), "Domain of negated constant does not have positive constant"); 241Debug.Assert(constants.Count > 0, "one of const is false?"); 283Debug.Assert((resourceName0 == null) != (resourceName1 == null),

System\Data\Mapping\ViewGeneration\Structures\NegatedConstant.cs (2)

33Debug.Assert(!values.Any(v => v is NegatedConstant), "Negated constant values must not contain another negated constant."); 181Debug.Assert(negatedConstants.Contains(constant), "Negated constant must contain all positive constants");

System\Data\Mapping\ViewGeneration\Structures\OpCellTreeNode.cs (9)

100Debug.Assert(m_children[0].RightDomainMap != null, "EdmMember domain map missing"); 116Debug.Assert(m_children.Count > 1, "No children for op node?"); 125Debug.Assert(m_children.Count > 1, "No children for op node?"); 266Debug.Assert(totalSlots == child.NumBoolSlots + child.NumProjectedSlots, 340Debug.Assert(OpType == CellTreeOpType.IJ || 360Debug.Assert(totalSlots == child.NumBoolSlots + child.NumProjectedSlots, 391Debug.Assert(children[0].IsProjected(keySlotNum), "Key is not in 0th child"); 392Debug.Assert(child.IsProjected(keySlotNum), "Key is not in child"); 467Debug.Assert(false == IsBoolSlot(slotNum), "Boolean slots cannot come from two children");

System\Data\Mapping\ViewGeneration\Structures\ProjectedSlot.cs (1)

119Debug.Assert(slots1.Length == slots2.Length, "Merged slots of two cells must be same size");

System\Data\Mapping\ViewGeneration\Structures\QualifiedCellIdBoolean.cs (1)

42Debug.Assert(blockAlias == null, "QualifiedCellIdBoolean: blockAlias mismatch");

System\Data\Mapping\ViewGeneration\Structures\ScalarConstant.cs (3)

33Debug.Assert(value != null, "Scalar const value must not be null."); 75Debug.Assert(outputMember.LeafEdmMember != null, "Constant can't correspond to an empty member path."); 141Debug.Assert(outputMember.LeafEdmMember != null, "Constant can't correspond to an empty member path.");

System\Data\Mapping\ViewGeneration\Structures\ScalarRestriction.cs (10)

37Debug.Assert(value is ScalarConstant || value.IsNull() || value.IsNotNull(), "value is expected to be ScalarConstant, NULL, or NOT_NULL."); 62Debug.Assert(IsComplete, "Ranges are fixed only for complete scalar restrictions."); 76Debug.Assert(!this.IsComplete, "CreateCompleteMemberRestriction must be called only for incomplete restrictions."); 93Debug.Assert(cqt == null, "unexpected construction order - cqt must be null"); 99Debug.Assert(cqt == null, "unexpected construction order - cqt must be null"); 100Debug.Assert(domainValues.Count > 0, "domain must not be empty"); 163Debug.Assert(domainValues.Count > 0, "domain must not be empty"); 266Debug.Assert(this.RestrictedMemberSlot.MemberPath.IsScalarType(), "Expected scalar."); 269Debug.Assert(this.Domain.Values.Count(c => c is NegatedConstant) <= 1, "Multiple negated constants?"); 307Debug.Assert(!includeNull || !excludeNull, "includeNull and excludeNull can't be true at the same time.");

System\Data\Mapping\ViewGeneration\Structures\TypeConstant.cs (2)

35Debug.Assert(type != null, "type must not be null."); 192Debug.Assert(m_edmType is StructuralType, "m_edmType must be a structural type.");

System\Data\Mapping\ViewGeneration\Structures\TypeRestriction.cs (5)

44Debug.Assert(value is TypeConstant || value.IsNull(), "Type or NULL expected."); 61Debug.Assert(IsComplete, "Ranges are fixed only for complete type restrictions."); 75Debug.Assert(!this.IsComplete, "CreateCompleteMemberRestriction must be called only for incomplete restrictions."); 93Debug.Assert(typeConstant != null || constant.IsNull(), "Constants for type checks must be type constants or NULLs"); 185Debug.Assert(typeConstant != null || constant.IsNull(), "Constants for type checks must be type constants or NULLs");

System\Data\Mapping\ViewGeneration\Utils\ExternalCalls.cs (11)

System\Data\Mapping\ViewGeneration\Validation\BasicCellRelation.cs (5)

35Debug.Assert(m_slots.Count > 0, "Cell relation with not even an exent?"); 59Debug.Assert(this == m_cellQuery.BasicCellRelation, "Cellquery does not point to the correct BasicCellRelation?"); 60Debug.Assert(m_cellQuery.Extent is EntitySet || m_cellQuery.Extent is AssociationSet, 109Debug.Assert(keys.Count > 0, "No keys for entity?"); 110Debug.Assert(keys.Count == 1, "Currently, we only support primary keys");

System\Data\Mapping\ViewGeneration\Validation\ExtentKey.cs (1)

68Debug.Assert(keyMember != null, "Bogus key member in metadata");

System\Data\Mapping\ViewGeneration\Validation\ForeignConstraint.cs (7)

293Debug.Assert(childEnd == null || parentEnd != childEnd, 626Debug.Assert(context.Extent.Equals(extent), "ViewgenContext extent and expected extent different"); 768Debug.Assert(childPaths != null, "child paths should be set"); 769Debug.Assert(parentPaths != null, "parent paths should be set"); 770Debug.Assert(errorParentCell != null, "errorParentCell should be set"); 787Debug.Assert(foundParentCell == true, "Some cell that mapped the parent's key must be present!"); 788Debug.Assert(foundChildCell == true, "Some cell that mapped the child's foreign key must be present according to the requires clause!");

System\Data\Mapping\ViewGeneration\Validation\KeyConstraint.cs (1)

30Debug.Assert(m_keySlots.Count > 0, "Key constraint being created without any keyslots?");

System\Data\Mapping\ViewGeneration\Validator.cs (2)

370Debug.Assert(cConstraints.KeyConstraints.Count() == cViewConstraints.KeyConstraints.Count(), 372Debug.Assert(sConstraints.KeyConstraints.Count() == sViewConstraints.KeyConstraints.Count(),

System\Data\Mapping\ViewGeneration\ViewgenContext.cs (1)

295Debug.Assert(alignedCells.Count == extentCellsList.Count, "Cell counts disagree");

System\Data\Mapping\ViewGeneration\ViewGenerator.cs (4)

269Debug.Assert(exception.ErrorLog.Count > 0, "Incorrectly created mapping exception"); 334Debug.Assert(exception.ErrorLog.Count > 0, 406Debug.Assert(mode != ViewGenMode.GenerateAllViews, "By definition this method can not handle generating views for all extents"); 458Debug.Assert(false == basicView.IsEmptyRightFragmentQuery, "Basic view is empty?");

System\Data\Mapping\ViewGeneration\ViewgenGatekeeper.cs (5)

38Debug.Assert(containerMapping.HasViews, "Precondition Violated: No mapping exists to generate views for!"); 67Debug.Assert(!type.Abstract, "Can not generate OfType/OfTypeOnly query view for and abstract type"); 127Debug.Assert(exception.ErrorLog.Count > 0, "Incorrectly created mapping exception"); 163Debug.Assert(cells.Count > 0, "There must be at least one cell in the container mapping"); 194Debug.Assert(exception.ErrorLog.Count > 0, "Incorrectly created mapping exception");

System\Data\Metadata\AspProxy.cs (2)

131Debug.Assert(path != null, "path == null"); 157Debug.Assert(miMapPath != null, "Unpexpected missing member in type System.Web.Hosting.HostingEnvironment");

System\Data\Metadata\CacheForPrimitiveTypes.cs (2)

98Debug.Assert(type == null, "type must be null here"); 182Debug.Assert(false, "Unexpected facet");

System\Data\Metadata\Converter.cs (21)

32Debug.Assert(Enum.GetUnderlyingType(typeof(ConcurrencyMode)) == typeof(int), "Please update underlying type below accordingly."); 49Debug.Assert(Enum.GetUnderlyingType(typeof(StoreGeneratedPattern)) == typeof(int), "Please update underlying type below accordingly."); 158Debug.Assert(convertedItemCache.ItemCollection.DataSpace == DataSpace.SSpace, "Did you add a new space?"); 182Debug.Assert(providerManifest != null, "This will make the dataspace to be default SSpace"); 186Debug.Assert(!convertedItemCache.ItemCollection.TryGetValue(element.FQName, false, out item), "Som should have checked for duplicate items"); 237Debug.Assert(element is Som.TypeElement && 275Debug.Assert(relationshipSet.Relationship.RelationshipKind == RelationshipKind.Association, 501Debug.Assert(associationType.ReferentialConstraints.Count == 0, "This must never have been initialized"); 941Debug.Assert(somFunctionImport.ReturnTypeList == null || somFunctionImport.ReturnTypeList.Count == 1, 944Debug.Assert(functionImportEntityContainer != null, "functionImportEntityContainer must be specified during function import conversion"); 950Debug.Assert(functionImportEntityContainer != null, "functionImportEntityContainer must be specified during function import conversion"); 1024Debug.Assert(!convertedItemCache.ItemCollection.TryGetValue(function.Identity, false, out returnFunction), 1045Debug.Assert(somEnumType != null, "somEnumType != null"); 1046Debug.Assert(newGlobalItems != null, "newGlobalItems != null"); 1047Debug.Assert(somEnumType.UnderlyingType is Som.ScalarType, "At this point the underlying type should have already been validated and should be ScalarType"); 1062Debug.Assert(somEnumMember.Value != null, "value must not be null at this point"); 1094Debug.Assert(null != element, "ConvertToDocumentation cannot be invoked with a null Som.Documentation element"); 1179Debug.Assert(somFunction.Schema.DataModel == Som.SchemaDataModelOption.EntityDataModel, "Enums live only in CSpace"); 1239Debug.Assert( 1333Debug.Assert(providerManifest != null, "null provider manifest will be consider as SSpace"); 1365Debug.Assert(scalarType != null, "Som scalar type should always resolve to a primitive type");

System\Data\Metadata\Edm\AssociationEndMember.cs (1)

51System.Diagnostics.Debug.Assert(null != value, "clearing GetRelatedEndMethod");

System\Data\Metadata\Edm\AssociationType.cs (2)

62Debug.Assert(IsReadOnly, "this is a wrapper around this.Members, don't call it during metadata loading, only call it after the metadata is set to read-only"); 109Debug.Assert(

System\Data\Metadata\Edm\ComplexType.cs (3)

66Debug.Assert(IsReadOnly, "this is a wrapper around this.Members, don't call it during metadata loading, only call it after the metadata is set to readonly"); 89Debug.Assert(Helper.IsEdmProperty(member) || Helper.IsNavigationProperty(member), 113System.Diagnostics.Debug.Assert(!String.IsNullOrEmpty(cspaceNamespaceName) &&

System\Data\Metadata\Edm\EdmFunction.cs (5)

34Debug.Assert(returnParameters.All((returnParameter) => returnParameter != null), "All return parameters must be non-null"); 35Debug.Assert(returnParameters.All((returnParameter) => returnParameter.Mode == ParameterMode.ReturnValue), "Return parameter in a function must have the ParameterMode equal to ReturnValue."); 62Debug.Assert(_returnParameters.Count == payload.EntitySets.Length, "The number of entity sets should match the number of return parameters"); 70Debug.Assert(_returnParameters.Count == 1, "If there was more than one result set payload.EntitySets should not have been null"); 90Debug.Assert(parameter.Mode != ParameterMode.ReturnValue, "No function parameter can have ParameterMode equal to ReturnValue.");

System\Data\Metadata\Edm\EdmProperty.cs (3)

64System.Diagnostics.Debug.Assert(name == propertyInfo.Name, "different PropertyName"); 130System.Diagnostics.Debug.Assert(null != value, "clearing ValueGetter"); 142System.Diagnostics.Debug.Assert(null != value, "clearing ValueSetter");

System\Data\Metadata\Edm\EdmType.cs (5)

114Debug.Assert(value != null, "The name should never be set to null"); 131Debug.Assert(value != null, "Namespace should never be set to null"); 168Debug.Assert(_baseType == null, "BaseType can't be set multiple times"); 174Debug.Assert(type != this, "Cannot set the given type as base type because it would introduce a loop in inheritance"); 180Debug.Assert(value == null ||

System\Data\Metadata\Edm\EntityContainer.cs (2)

213Debug.Assert(function != null, "function != null"); 214Debug.Assert(function.IsFunctionImport, "function.IsFunctionImport");

System\Data\Metadata\Edm\EntitySet.cs (1)

141Debug.Assert(associationSet.ElementType.ReferentialConstraints.Count == 1, "Expected exactly one constraint for FK");

System\Data\Metadata\Edm\EntityType.cs (4)

94Debug.Assert(Helper.IsEdmProperty(member) || Helper.IsNavigationProperty(member), 157Debug.Assert(IsReadOnly, "this is a wrapper around this.Members, don't call it during metadata loading, only call it after the metadata is set to readonly"); 249System.Diagnostics.Debug.Assert(!String.IsNullOrEmpty(cspaceNamespaceName) && 327Debug.Assert(ClrType != null, "Expecting non-null CLRType of o-space EntityType.");

System\Data\Metadata\Edm\EntityTypeBase.cs (3)

55Debug.Assert(_keyMembers.Count == 0, "Since the base type have keys, current type cannot have keys defined"); 83Debug.Assert(_keyMemberNames.Length == this.KeyMembers.Count, "This list is out of sync with the key members count. This property was called before all the keymembers were added"); 101Debug.Assert(this.BaseType == null || ((EntityTypeBase)this.BaseType).KeyMembers.Count == 0,

System\Data\Metadata\Edm\EnumMember.cs (2)

50Debug.Assert(value != null, "value != null"); 51Debug.Assert(value is SByte || value is Byte || value is Int16 || value is Int32 || value is Int64, "Unsupported type of enum member value.");

System\Data\Metadata\Edm\EnumType.cs (11)

65Debug.Assert(underlyingType != null, "underlyingType != null"); 66Debug.Assert(Helper.IsSupportedEnumUnderlyingType(underlyingType.PrimitiveTypeKind), "Unsupported underlying type for enum."); 67Debug.Assert(dataSpace == DataSpace.CSpace || dataSpace == DataSpace.OSpace, "Enums can be only defined in CSpace or OSpace."); 89Debug.Assert(clrType != null, "clrType != null"); 90Debug.Assert(clrType.IsEnum, "enum type expected"); 94Debug.Assert(_underlyingType != null, "only primitive types expected here."); 95Debug.Assert(Helper.IsSupportedEnumUnderlyingType(_underlyingType.PrimitiveTypeKind), 167Debug.Assert(enumMember != null, "enumMember != null"); 196Debug.Assert(clrType != null, "clrType != null"); 197Debug.Assert(clrType.IsEnum, "enum type expected"); 198Debug.Assert(!String.IsNullOrEmpty(cspaceNamespaceName) && !String.IsNullOrEmpty(cspaceTypeName), "Mapping information must never be null");

System\Data\Metadata\Edm\Facet.cs (1)

93Debug.Assert(

System\Data\Metadata\Edm\FacetDescription.cs (2)

79Debug.Assert(FacetDescription.IsNumericType(facetType), "Min and Max Values can only be specified for numeric facets"); 83Debug.Assert(minValue != maxValue, "minValue should not be equal to maxValue");

System\Data\Metadata\Edm\FacetValueContainer.cs (2)

62Debug.Assert(object.ReferenceEquals(unbounded, EdmConstants.UnboundedValue), "you must pass the unbounded value. If you are trying to set null, use the T parameter overload"); 77Debug.Assert(_hasValue, "Don't get the value if it has not been set");

System\Data\Metadata\Edm\FilteredReadOnlyMetadataCollection.cs (1)

52Debug.Assert(collection.IsReadOnly, "wrappers should only be created once loading is over, and this collection is still loading");

System\Data\Metadata\Edm\GlobalItem.cs (2)

52Debug.Assert(GetDataSpace() != (DataSpace)(-1) || this.BuiltInTypeKind == BuiltInTypeKind.RowType || this.BuiltInTypeKind == BuiltInTypeKind.CollectionType, "DataSpace must have some valid value"); 59Debug.Assert(GetDataSpace() == (DataSpace)(-1) || GetDataSpace() == value || this.BuiltInTypeKind == BuiltInTypeKind.RowType || this.BuiltInTypeKind == BuiltInTypeKind.CollectionType, "Invalid Value being set for DataSpace");

System\Data\Metadata\Edm\ItemCollection.cs (2)

89Debug.Assert(item.IsReadOnly, "The item is not readonly, it should be by the time it is added to the item collection"); 208Debug.Assert(_itemsCache != null, "check the initialization of the Memoizer");

System\Data\Metadata\Edm\LightweightCodeGenerator.cs (8)

44Debug.Assert(null != getter, "null getter"); 86Debug.Assert(null != setter, "null setter"); 102Debug.Assert(null != getRelatedEnd, "null getRelatedEnd"); 193Debug.Assert(!default(RuntimeTypeHandle).Equals(entityDeclaringType), "Type handle of entity should always be known."); 388Debug.Assert(null != (Action<Object,Type,String,String>)EntityUtil.ThrowSetInvalidValue, "missing method ThrowSetInvalidValue(object,Type,string,string)"); 401Debug.Assert(!default(RuntimeTypeHandle).Equals(entityDeclaringType), "Type handle of entity should always be known."); 468Debug.Assert(sourceMember.DeclaringType == targetMember.DeclaringType, "Source and Target members must be in the same DeclaringType"); 476Debug.Assert(genericCreateRelatedEndMethod != null, "Could not find method LightweightCodeGenerator.CreateGetRelatedEndMethod");

System\Data\Metadata\Edm\MemberCollection.cs (2)

61Debug.Assert(declaringType != null, "This member collection must belong to a declaring type"); 339Debug.Assert(member.DeclaringType == null, string.Format(CultureInfo.CurrentCulture, "The member {0} already has a declaring type, it cannot be added to this collection.", argumentName));

System\Data\Metadata\Edm\MetadataCollection.cs (6)

64Debug.Assert(!String.IsNullOrEmpty(item.Identity), "Identity of the item must never be null or empty"); 220Debug.Assert(collectionData != null && collectionData.IdentityDictionary != null, "the identity dictionary is null"); 221Debug.Assert(!String.IsNullOrEmpty(identity), "empty identity"); 481Debug.Assert(null != identity, "null identity"); 515Debug.Assert(ignoreCase == (0 <= index), "indexof verification"); 654Debug.Assert((index < 0) ||

System\Data\Metadata\Edm\MetadataItem.cs (1)

261Debug.Assert(System.Convert.ToInt32(flag & ~MetadataFlags.Readonly,CultureInfo.InvariantCulture) == 0,

System\Data\Metadata\Edm\NavigationProperty.cs (2)

47System.Diagnostics.Debug.Assert(name == propertyInfo.Name, "different PropertyName?"); 143Debug.Assert(

System\Data\Metadata\Edm\NavigationPropertyAccessor.cs (5)

62System.Diagnostics.Debug.Assert(null != value, "clearing ValueGetter"); 74System.Diagnostics.Debug.Assert(null != value, "clearing ValueSetter"); 85System.Diagnostics.Debug.Assert(null != value, "clearing CollectionAdd"); 96System.Diagnostics.Debug.Assert(null != value, "clearing CollectionRemove"); 107System.Diagnostics.Debug.Assert(null != value, "clearing CollectionCreate");

System\Data\Metadata\Edm\PrimitiveType.cs (3)

72Debug.Assert(clrType == ClrEquivalentType, "not equivalent to ClrEquivalentType"); 120Debug.Assert(_providerManifest != null, "This primitive type should have been added to a manifest, which should have set this"); 125Debug.Assert(value != null, "This primitive type should have been added to a manifest, which should have set this");

System\Data\Metadata\Edm\Provider\EdmProviderManifest.cs (4)

90Debug.Assert(type is PrimitiveType, "EdmProviderManifest.GetFacetDescriptions(): Argument is not a PrimitiveType"); 224Debug.Assert(clrType == primitiveType.ClrEquivalentType, "ClrEquivalentType mismatch"); 866Debug.Assert(null != typeUsage, "TypeUsage must not be null"); 898Debug.Assert(primitiveType != null, "type argument must be primitive in order to use this function");

System\Data\Metadata\Edm\Provider\EdmProviderManifestFunctionBuilder.cs (4)

23Debug.Assert(edmPrimitiveTypes != null, "Primitive types should not be null"); 30Debug.Assert((int)edmType.PrimitiveTypeKind < primitiveTypeUsages.Length && (int)edmType.PrimitiveTypeKind >= 0, "Invalid PrimitiveTypeKind value?"); 31Debug.Assert(primitiveTypeUsages[(int)edmType.PrimitiveTypeKind] == null, "Duplicate PrimitiveTypeKind value in EDM primitive types?"); 79Debug.Assert(!string.IsNullOrEmpty(aggregateFunctionName) && !string.IsNullOrWhiteSpace(aggregateFunctionName), "Aggregate function name should be valid");

System\Data\Metadata\Edm\RelationshipType.cs (1)

49Debug.Assert(IsReadOnly, "this is a wrapper around this.Members, don't call it during metadata loading, only call it after the metadata is set to readonly");

System\Data\Metadata\Edm\RowType.cs (2)

90Debug.Assert(IsReadOnly, "this is a wrapper around this.Members, don't call it during metadata loading, only call it after the metadata is set to readonly"); 121Debug.Assert(Helper.IsEdmProperty(member), "Only members of type Property may be added to Row types.");

System\Data\Metadata\Edm\SafeLink.cs (1)

36Debug.Assert(link._value == null || link._value == parent, "don't try to hook up the same child to a different parent");

System\Data\Metadata\Edm\StructuralType.cs (1)

107Debug.Assert(this.DataSpace == member.TypeUsage.EdmType.DataSpace || this.BuiltInTypeKind == BuiltInTypeKind.RowType, "Wrong member type getting added in structural type");

System\Data\Metadata\Edm\TypeUsage.cs (1)

457System.Diagnostics.Debug.Assert(false, "Unexpected type found in entity data reader");

System\Data\Metadata\Edm\util.cs (2)

31Debug.Assert(item != null, "The given item is null"); 46Debug.Assert(!string.IsNullOrEmpty(item.Identity), "Item has empty identity.");

System\Data\Metadata\EdmItemCollection.cs (2)

456Debug.Assert(function.IsModelDefinedFunction, "Function definition can be requested only for user-defined model functions."); 477Debug.Assert(generatedDefinition != null, "generatedDefinition != null");

System\Data\Metadata\EdmValidator.cs (2)

150Debug.Assert(item != null, "InternalValidate is called with a null item, the caller should check for null first"); 210Debug.Assert(false, "An instance with a built in type kind refering to the abstract type " + item.BuiltInTypeKind + " is encountered");

System\Data\Metadata\Helper.cs (13)

107Debug.Assert(firstType != null, "firstType should not be not null"); 121Debug.Assert(firstType != null, "firstType should not be not null"); 185Debug.Assert(stringList != null , "Expecting a non null list"); 344Debug.Assert(edmType != null, "edmType != null"); 472Debug.Assert(false, "which ParameterDirection.ToString() is missing?"); 491Debug.Assert(false, "which ParameterMode.ToString() is missing?"); 534Debug.Assert(IsSupportedEnumUnderlyingType(underlyingTypeKind), "Unsupported underlying type."); 548Debug.Assert(type != null, "type != null"); 549Debug.Assert(IsScalarType(type), "This method must not be called for types that are neither primitive nor enums."); 563Debug.Assert(type != null, "type != null"); 564Debug.Assert(IsEnumType(type), "This method can be called only for enums."); 571Debug.Assert(type != null, "type != null"); 572Debug.Assert(IsPrimitiveType(type), "This method can be called only for enums.");

System\Data\Metadata\MappingMetadataHelper.cs (1)

26Debug.Assert(entityType != null, "EntityType parameter should not be null.");

System\Data\Metadata\MetadataArtifactLoader.cs (1)

417Debug.Assert(false, "Invalid DataSpace specified.");

System\Data\Metadata\MetadataArtifactLoaderCompositeFile.cs (1)

182Debug.Assert(false, "Invalid DataSpace value.");

System\Data\Metadata\MetadataArtifactLoaderCompositeResource.cs (1)

315Debug.Assert(!string.IsNullOrEmpty(resourceName), "we should not get here is the resourceName is null");

System\Data\Metadata\MetadataArtifactLoaderFile.cs (1)

80Debug.Assert(false, "object is not a MetadataArtifactLoaderFile");

System\Data\Metadata\MetadataArtifactLoaderResource.cs (1)

75Debug.Assert(false, "object is not a MetadataArtifactLoaderResource");

System\Data\Metadata\MetadataArtifactLoaderXmlReaderWrapper.cs (1)

77Debug.Assert(false, "object is not a MetadataArtifactLoaderXmlReaderWrapper");

System\Data\Metadata\MetadataCache.cs (18)

108Debug.Assert(!string.IsNullOrEmpty(paths), "paths cannot be empty or null"); 367Debug.Assert(entry.IsLoaded, "The entry must be loaded at this point"); 448Debug.Assert(_entryTokenReference.IsAlive, "You must call Ensure token before you call this method"); 449Debug.Assert(_markEntryForCleanup == false, "The entry must not be marked for cleanup"); 450Debug.Assert(_itemCollection == null, "Item collection must be null"); 451Debug.Assert(_filePermissions == null, "filePermissions must be null"); 484Debug.Assert(_entryTokenReference.IsAlive == false, "Entry Token must never be alive if the entry is marked for cleanup"); 539Debug.Assert(_markEntryForCleanup == false, "An entry with alive token cannot be marked for cleanup"); 549Debug.Assert(_weakReferenceItemCollection.IsAlive, "Since the strong reference is still there, weak reference must also be alive"); 556Debug.Assert(_markEntryForCleanup, "Since the strong reference is null, this entry must be marked for cleanup"); 582Debug.Assert(_itemCollection != null, "Item collection must be present since we want to reuse the metadata"); 583Debug.Assert(_entryTokenReference.IsAlive, "This entry must be in use"); 584Debug.Assert(_markEntryForCleanup == false, "The entry must not marked for cleanup"); 585Debug.Assert(_weakReferenceItemCollection.IsAlive, "Weak reference to item collection must be alive"); 636Debug.Assert(loader != null, "loader is null"); 825Debug.Assert(loader != null, "loader must never be null"); 852Debug.Assert(edmItemCollection != null, "EdmItemCollection must never be null"); 853Debug.Assert(loader != null, "loader must never be null");

System\Data\Metadata\MetadataWorkspace.cs (13)

137Debug.Assert(XmlConstants.SchemaVersionLatest == XmlConstants.EdmVersionForV3, "Did you add a new version?"); 242Debug.Assert(collection.DataSpace == DataSpace.OCSpace, "Invalid DataSpace Enum value: " + collection.DataSpace); 400Debug.Assert(null != type, "null type"); 448Debug.Assert(null != type, "null type"); 1001Debug.Assert( 1027Debug.Assert( 1118Debug.Assert( 1143Debug.Assert( 1261Debug.Assert(edmSpaceTypeUsage.EdmType != null, "The TypeUsage object does not have an EDMType."); 1279Debug.Assert(!Helper.IsPrimitiveType(clrType) || 1310Debug.Assert(this.IsItemCollectionAlreadyRegistered(DataSpace.CSSpace) && 1316Debug.Assert(!result || 1476Debug.Assert(null != _itemsSSpace, "_itemsSSpace must not be null");

System\Data\Metadata\ObjectHelper.cs (11)

66Debug.Assert(count!=0, "Empty Error List"); 145Debug.Assert(edmProperty.TypeUsage.EdmType.DataSpace == DataSpace.CSpace, "cspace property must have a cspace type"); 146Debug.Assert(columnProperty.TypeUsage.EdmType.DataSpace == DataSpace.SSpace, "sspace type usage must have a sspace type"); 147Debug.Assert( 150Debug.Assert(Helper.IsPrimitiveType(columnProperty.TypeUsage.EdmType), "sspace property must contain a primitive type"); 204Debug.Assert(cspaceType != null, "cspaceType != null"); 205Debug.Assert(storeType != null, "storeType != null"); 206Debug.Assert(cspaceType.EdmType.DataSpace == DataSpace.CSpace, "cspace property must have a cspace type"); 207Debug.Assert(storeType.EdmType.DataSpace == DataSpace.CSpace, "storeType type usage must have a sspace type"); 208Debug.Assert( 211Debug.Assert(Helper.IsPrimitiveType(storeType.EdmType), "storeType property must be a primitive type");

System\Data\Metadata\ObjectItemCollection.cs (6)

498Debug.Assert(objectSpaceType == null || objectSpaceType is StructuralType || objectSpaceType is EnumType, 520Debug.Assert(objectSpaceType == null || objectSpaceType is StructuralType || objectSpaceType is EnumType, 534Debug.Assert(objectSpaceType is ClrEntityType || objectSpaceType is ClrComplexType || objectSpaceType is ClrEnumType, 539Debug.Assert(clrType != null, "ClrType property of ClrEntityType/ClrComplexType/ClrEnumType objects must not be null"); 575Debug.Assert(DataSpace.CSpace == cspaceType.DataSpace, "DataSpace should be CSpace"); 595Debug.Assert(DataSpace.OSpace == edmType.DataSpace, "DataSpace must be OSpace");

System\Data\Metadata\ObjectLayer\AssemblyCache.cs (2)

42Debug.Assert(loaderCookie == null || loaderCookie is Func<Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>, "This is a bad loader cookie"); 117Debug.Assert(entry != null, "we should always have an entry, why don't we?");

System\Data\Metadata\ObjectLayer\KnownAssembliesSet.cs (1)

80Debug.Assert(current.SeenWithEdmItemCollection != knownAssemblyEntry.SeenWithEdmItemCollection &&

System\Data\Metadata\ObjectLayer\KnownAssemblyEntry.cs (1)

24Debug.Assert(cacheEntry != null, "Found a null cacheEntry");

System\Data\Metadata\ObjectLayer\LoadMessageLogger.cs (2)

45Debug.Assert(relatedType != null, "have to pass in a type to get the message"); 62Debug.Assert(relatedType != null, "have to have a type with this message");

System\Data\Metadata\ObjectLayer\LockedAssemblyCache.cs (1)

52Debug.Assert(entered, "The cache is being accessed by a thread that isn't holding the lock");

System\Data\Metadata\ObjectLayer\ObjectItemAssemblyLoader.cs (2)

117Debug.Assert(loaderCookie == null || loaderCookie is Func<Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>, "Non loader cookie passed in"); 143Debug.Assert(!_sessionData.KnownAssemblies.Contains(_assembly, SessionData.ObjectItemAssemblyLoaderFactory, _sessionData.EdmItemCollection), "This assembly must not be present in the list of known assemblies");

System\Data\Metadata\ObjectLayer\ObjectItemAttributeAssemblyLoader.cs (19)

39Debug.Assert(Create == sessionData.ObjectItemAssemblyLoaderFactory, "Why is there a different factory creating this class"); 69Debug.Assert(IsSchemaAttributePresent(SourceAssembly), "LoadAssembly shouldn't be called with assembly having no schema attribute"); 70Debug.Assert(!SessionData.KnownAssemblies.Contains(SourceAssembly, SessionData.ObjectItemAssemblyLoaderFactory, SessionData.EdmItemCollection), "InternalLoadAssemblyFromCache: This assembly must not be present in the list of known assemblies"); 139Debug.Assert(!SessionData.TypesInLoading.ContainsKey(clrType.FullName), "This should be called only after looking in typesInLoading"); 140Debug.Assert(SessionData.EdmItemErrors.Count > 0 || // had an error during loading 148Debug.Assert(SessionData.KnownAssemblies.Contains(clrType.Assembly, SessionData.LoaderCookie, SessionData.EdmItemCollection), "We should only be loading things directly from the cache if they are already in the collection"); 250Debug.Assert(!CacheEntry.ContainsType(associationType.FullName), "Relationship type must not be present in the list of types"); 276Debug.Assert(clrType.Assembly == SourceAssembly, "Why are we loading a type that is not in our assembly?"); 277Debug.Assert(!SessionData.TypesInLoading.ContainsKey(clrType.FullName), "Trying to load a type that is already loaded???"); 278Debug.Assert(!clrType.IsGenericType, "Generic type is not supported"); 313Debug.Assert(typeAttribute is EdmEnumTypeAttribute, "Invalid type attribute encountered"); 338Debug.Assert(!CacheEntry.ContainsType(edmType.Identity), "This type must not be already present in the list of types for this assembly"); 517Debug.Assert(propertyInfo.IsDefined(typeof(EdmRelationshipNavigationPropertyAttribute), false), "The property must have navigation property defined"); 524Debug.Assert(relationshipPropertyAttributes.Length == 1, "There should be exactly one property for every navigation property"); 617Debug.Assert(property.IsDefined(typeof(EdmScalarPropertyAttribute), false), "The property must have a scalar attribute"); 636Debug.Assert(attrs.Length == 1, "Every property can exactly have one ScalarProperty Attribute"); 656Debug.Assert(declaringType != null, "type != null"); 657Debug.Assert(clrProperty != null, "clrProperty != null"); 658Debug.Assert(

System\Data\Metadata\ObjectLayer\ObjectItemConventionAssemblyLoader.cs (39)

31Debug.Assert(Create == sessionData.ObjectItemAssemblyLoaderFactory, "Why is there a different factory creating this class"); 51Debug.Assert(ospaceType is StructuralType || Helper.IsEnumType(ospaceType), "Only StructuralType or EnumType expected."); 73Debug.Assert(CacheEntry.ClosureAssemblies.Count == 0, "How did we get closure assemblies?"); 100Debug.Assert(pair.Value > 1, "how did we get a negative count of types in the dictionary?"); 118Debug.Assert(type != null, "type != null"); 119Debug.Assert(cspaceType != null, "cspaceType != null"); 120Debug.Assert(cspaceType is StructuralType || Helper.IsEnumType(cspaceType), "Structural or enum type expected"); 153Debug.Assert(type != null, "type != null"); 154Debug.Assert(cspaceType != null, "cspaceType != null"); 158Debug.Assert(TypesMatchByConvention(type, cspaceType), "The types passed as parameters don't match by convention."); 167Debug.Assert(Helper.IsComplexType(cspaceType), "Invalid type attribute encountered"); 218Debug.Assert(enumType != null, "enumType != null"); 219Debug.Assert(enumType.IsEnum, "enum type expected"); 220Debug.Assert(cspaceEnumType != null, "cspaceEnumType != null"); 221Debug.Assert(Helper.IsEnumType(cspaceEnumType), "Enum type expected"); 222Debug.Assert(TypesMatchByConvention(enumType, cspaceEnumType), "The types passed as parameters don't match by convention."); 246Debug.Assert(enumType != null, "enumType != null"); 247Debug.Assert(enumType.IsEnum, "expected enum OSpace type"); 248Debug.Assert(cspaceEnumType != null, "cspaceEnumType != null"); 249Debug.Assert(Helper.IsEnumType(cspaceEnumType), "Enum type expected"); 282Debug.Assert(enumType != null, "enumType != null"); 283Debug.Assert(enumType.IsEnum, "expected enum OSpace type"); 284Debug.Assert(cspaceEnumType != null, "cspaceEnumType != null"); 285Debug.Assert(Helper.IsEnumType(cspaceEnumType), "Enum type expected"); 286Debug.Assert(cspaceEnumType.UnderlyingType.ClrEquivalentType == enumType.GetEnumUnderlyingType(), "underlying types should have already been checked"); 348Debug.Assert(!foundValue || ospaceType is StructuralType, "Structural type expected (if found)."); 490Debug.Assert(propertyType is StructuralType, "Structural type expected."); 511Debug.Assert(ospaceRelationship is StructuralType, "Structural type expected."); 521Debug.Assert(findType is StructuralType, "Structural type expected."); 532Debug.Assert(findType is StructuralType, "Structural type expected."); 539Debug.Assert(foundTarget, "Since the relationship will only be created if it can find the types for both ends, we will never fail to find one of the ends"); 681Debug.Assert(cspaceAssociation.RelationshipEndMembers.Count == 2, "Relationships are assumed to have exactly two ends"); 741Debug.Assert(type != null, "type != null"); 742Debug.Assert(clrProperty != null, "clrProperty != null"); 743Debug.Assert(clrProperty.CanRead && clrProperty.CanWrite, "The clr property has to have a setter and a getter."); 744Debug.Assert(ospaceType != null, "ospaceType != null"); 745Debug.Assert(cspaceProperty != null, "cspaceProperty != null"); 746Debug.Assert(propertyType != null, "propertyType != null"); 747Debug.Assert(Helper.IsScalarType(propertyType), "Property has to be primitive or enum.");

System\Data\Metadata\ObjectLayer\ObjectItemLoadingSessionData.cs (3)

109Debug.Assert(_loaderFactory == null || _typesInLoading.Count == 0, "Only reset the factory after types have not been loaded or load from the cache"); 122Debug.Assert(_loaderFactory == null || 132Debug.Assert(loaderCookie == null || loaderCookie is Func<Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>, "This is a bad loader cookie");

System\Data\Metadata\StoreItemCollection.cs (3)

55Debug.Assert(factory != null, "factory is null"); 56Debug.Assert(manifest != null, "manifest is null"); 366Debug.Assert(sTypeFunction.DataSpace == Edm.DataSpace.SSpace, "sTypeFunction.DataSpace == Edm.DataSpace.SSpace");

System\Data\Metadata\StoreItemCollection.Loader.cs (2)

76Debug.Assert(_errors == null, "we are expecting this to be the location that sets _errors for the first time"); 123Debug.Assert(expected != null, "Expected provider name not initialized from _provider or _providerFactory?");

System\Data\Metadata\TypeHelpers.cs (9)

444Debug.Assert(scalarType != null, "scalarType != null"); 445Debug.Assert(TypeSemantics.IsScalarType(scalarType), "Primitive or enum type expected."); 459Debug.Assert(enumTypeUsage != null, "enumTypeUsage != null"); 460Debug.Assert(TypeSemantics.IsEnumerationType(enumTypeUsage), "enumTypeUsage is not an enumerated type"); 472Debug.Assert(spatialTypeUsage != null, "spatialTypeUsage != null"); 473Debug.Assert(TypeSemantics.IsStrongSpatialType(spatialTypeUsage), "spatialTypeUsage is not a strong spatial type"); 677Debug.Assert(entitySet.EntityContainer != null, "entitySet.EntityContainer is null"); 800Debug.Assert(false, "Integer primitive type was not one of Byte, Int16, Int32, Int64, SByte?"); 843Debug.Assert(!isCanonicalFunction || (isCanonicalFunction && !function.HasUserDefinedBody),

System\Data\Metadata\TypeSemantics.cs (25)

103Debug.Assert(subType != null, "subType must not be NULL"); 104Debug.Assert(superType != null, "superType must not be NULL"); 138Debug.Assert(fromType != null, "fromType must not be NULL"); 139Debug.Assert(toType != null, "toType must not be NULL"); 217Debug.Assert(fromType != null, "fromType != null"); 218Debug.Assert(toType != null, "toType != null"); 239Debug.Assert(type1 != null, "type1 must not be NULL"); 240Debug.Assert(type2 != null, "type2 must not be NULL"); 327Debug.Assert(!IsEnumerationType(type), "Implicit cast/Softcast is not allowed for enums so we should never see enum type here."); 379Debug.Assert(type != null, "type != null"); 401Debug.Assert(type != null, "type != null"); 676Debug.Assert(null != type, "type must not be null"); 713System.Diagnostics.Debug.Assert(assertPredicate(), 726Debug.Assert(fromType != null, "fromType must not be null"); 727Debug.Assert(Helper.IsPrimitiveType(fromType.EdmType), "fromType must be primitive type"); 728Debug.Assert(toType != null, "toType must not be null"); 729Debug.Assert(Helper.IsPrimitiveType(toType.EdmType), "toType must be primitive type"); 781Debug.Assert(fromType != null, "fromType must not be null"); 782Debug.Assert(Helper.IsPrimitiveType(fromType.EdmType), "fromType must be primitive type"); 783Debug.Assert(toType != null, "toType must not be null"); 784Debug.Assert(Helper.IsPrimitiveType(toType.EdmType), "toType must be primitive type"); 850Debug.Assert(type1 != null, "type1 must not be null"); 851Debug.Assert(Helper.IsPrimitiveType(type1.EdmType), "type1 must be primitive type"); 852Debug.Assert(type2 != null, "type2 must not be null"); 853Debug.Assert(Helper.IsPrimitiveType(type2.EdmType), "type2 must be primitive type");

System\Data\Objects\DataClasses\ComplexObject.cs (8)

42Debug.Assert(null != parent, "Attempt to attach to a null parent"); 43Debug.Assert(null != parentPropertyName, "Must provide parentPropertyName in order to attach"); 64Debug.Assert(_parent != null, "Attempt to detach from a null _parent"); 65Debug.Assert(_parentPropertyName != null, "Null _parentPropertyName on a non-null _parent"); 133Debug.Assert(complexObject != null, "invalid complexObject"); 134Debug.Assert(!String.IsNullOrEmpty(complexMemberName), "invalid complexMemberName"); 163Debug.Assert(complexObject != null, "invalid complexObject"); 164Debug.Assert(!String.IsNullOrEmpty(complexMemberName), "invalid complexMemberName");

System\Data\Objects\DataClasses\EntityCollection.cs (13)

System\Data\Objects\DataClasses\EntityObject.cs (9)

87Debug.Assert(EntityChangeTracker != null, 89Debug.Assert(EntityChangeTracker != s_detachedEntityChangeTracker ? EntityChangeTracker.EntityState != EntityState.Detached : true, 114Debug.Assert(EntityChangeTracker != null, "_entityChangeTracker should never be null -- if detached it should return s_detachedEntityChangeTracker"); 187Debug.Assert(EntityChangeTracker != null, "_entityChangeTracker should never be null -- if detached it should return s_detachedEntityChangeTracker"); 209Debug.Assert(EntityChangeTracker != null, "EntityChangeTracker should never return null -- if detached it should be return s_detachedEntityChangeTracker"); 243Debug.Assert(complexObject != null, "invalid complexObject"); 244Debug.Assert(!String.IsNullOrEmpty(complexMemberName), "invalid complexMemberName"); 266Debug.Assert(complexObject != null, "invalid complexObject"); 267Debug.Assert(!String.IsNullOrEmpty(complexMemberName), "invalid complexMemberName");

System\Data\Objects\DataClasses\EntityReference.cs (20)

92Debug.Assert(this.WrappedOwner.Entity != null, "Unexpected null Owner on EntityReference attached to a context"); 137Debug.Assert(attachedKey == null, "Found more than one non-Deleted relationship for the same AssociationSet and source role"); 144Debug.Assert(attachedKey == null || IsValidEntityKeyType(attachedKey), 175Debug.Assert(this.WrappedOwner.Entity != null, "Unexpected null Owner on EntityReference attached to a context"); 329Debug.Assert(this.ObjectContext != null && !UsingNoTracking, "Should only need to access AttachedEntityKey property on attached EntityReferences"); 405Debug.Assert(CachedForeignKey != null || EntityKey == null, "CachedForeignKey should not be null if EntityKey is not null."); 463Debug.Assert(dependentEntity.Entity != null, "dependentEntity.Entity == null"); 464Debug.Assert(principalEntity.Entity != null, "principalEntity.Entity == null"); 465Debug.Assert(this.IsForeignKey, "cannot update foreign key values if the relationship is not a FK"); 467Debug.Assert(constraint != null, "null constraint"); 533Debug.Assert(keyIndex >= 0 && keyIndex < numValues, "Could not find constraint prop name in entity set key names"); 567Debug.Assert(dependentEntity.Entity != null, "dependentEntity.Entity == null"); 568Debug.Assert(principalKey != null, "principalKey == null"); 569Debug.Assert(!principalKey.IsTemporary, "Cannot update from a temp key"); 570Debug.Assert(this.IsForeignKey, "cannot update foreign key values if the relationship is not a FK"); 572Debug.Assert(constraint != null, "null constraint"); 618Debug.Assert(RelationshipNavigation != null, "null RelationshipNavigation"); 629Debug.Assert(ObjectContext != null, "Nulling FKs only works when attached."); 630Debug.Assert(IsForeignKey, "Cannot null FKs for independent associations."); 646Debug.Assert(entry != null, "State entry must exist while detaching.");

System\Data\Objects\DataClasses\EntityReference_TResultType.cs (9)

259Debug.Assert(this.ObjectContext != null, "Should not be trying to add entities to state manager if context is null"); 372Debug.Assert(this.ObjectContext != null, "Should not be trying to remove entities from state manager if context is null"); 391Debug.Assert(IsForeignKey || relationshipEntry != null, "Should have been able to find a valid relationship since _cachedValue is non-null"); 557Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null."); 558Debug.Assert(null == _wrappedCachedValue.Entity || wrappedEntity.Entity == _wrappedCachedValue.Entity, "The specified object is not a part of this relationship."); 583Debug.Assert(wrappedEntity != null, "IEntityWrapper instance is null."); 620Debug.Assert(constraint.FromProperties.Count == constraint.ToProperties.Count, "Referential constraints From/To properties list have different size"); 694Debug.Assert(this._wrappedCachedValue.Entity == null, "The EntityReference already has a value."); 705Debug.Assert(this.RelationshipNavigation != null, "null RelationshipNavigation");

System\Data\Objects\DataClasses\RelatedEnd.cs (77)

System\Data\Objects\DataClasses\RelationshipManager.cs (39)

System\Data\Objects\ELinq\CompiledELinqQueryState.cs (3)

55Debug.Assert(this.Span == null, "Include span specified on compiled LINQ-based ObjectQuery instead of within the expression tree?"); 56Debug.Assert(this._cachedPlan == null, "Cached plan should not be set on compiled LINQ queries"); 176Debug.Assert(plan != null, "Failed to produce an execution plan?");

System\Data\Objects\ELinq\ELinqQueryState.cs (2)

94Debug.Assert(this.Span == null, "Include span specified on compiled LINQ-based ObjectQuery instead of within the expression tree?"); 243Debug.Assert(includeMethod != null, "Unable to find ObjectQuery.Include method?");

System\Data\Objects\ELinq\ExpressionConverter.cs (4)

433Debug.Assert(leftSpan != null || rightSpan != null, "Span mappings contain null?"); 725Debug.Assert(availableParams != null, "Parameter collection cannot be null"); 1380Debug.Assert(preparedValue != null, "The prepared value should not be null when the input is non-null"); 1512Debug.Assert(null != candidateFunctions && candidateFunctions.Count > 0, "provider functions must not be null or empty");

System\Data\Objects\ELinq\Funcletizer.cs (1)

138Debug.Assert(_mode == Mode.ConventionalQuery, "No other options...");

System\Data\Objects\ELinq\InitializerFacet.cs (3)

112Debug.Assert(null != other, "must not use a null key"); 471Debug.Assert(propertyTranslatorResults.Count > 1, "no properties?"); 472Debug.Assert(propertyTranslatorResults[1] is CollectionTranslatorResult, "not a collection?");

System\Data\Objects\ELinq\MethodCallTranslator.cs (22)

System\Data\Objects\ELinq\ObjectQueryProvider.cs (2)

38Debug.Assert(null != context, "context must be given"); 51Debug.Assert(null != query, "query must be given");

System\Data\Objects\ELinq\SpatialMethodCallTranslator.cs (4)

46Debug.Assert(method.IsStatic && method.IsPublic && 55Debug.Assert(!method.IsStatic && method.IsPublic && 239Debug.Assert(call.Object == null, "Static method call with instance argument?"); 244Debug.Assert(call.Object != null, "Instance method call with no instance argument?");

System\Data\Objects\ELinq\SpatialPropertyTranslator.cs (2)

46Debug.Assert(property.GetGetMethod().IsPublic && 157Debug.Assert(call.Expression != null, "No static spatial properties currently map to canonical functions");

System\Data\Objects\ELinq\Translator.cs (4)

364Debug.Assert(clrMember is PropertyInfo, "Navigation property was not a property; should not be allowed by metadata."); 387Debug.Assert(null != countMethod, "Count() must exist"); 667Debug.Assert(!TypeSemantics.IsCollectionType(argument.ResultType), "Did not expect collection type"); 687Debug.Assert(!TypeSemantics.IsCollectionType(argument.ResultType), "Did not expect collection type");

System\Data\Objects\ELinq\TypeSystem.cs (4)

91Debug.Assert(null != expression, "expression required"); 92Debug.Assert(null != requiredType, "requiredType"); 242Debug.Assert(interfaceType.IsInterface, "Ensure interfaceType is an interface before calling IsImplementationOf"); 257Debug.Assert(Enumerable.Contains(propertyInfo.DeclaringType.GetInterfaces(), interfaceType), "Ensure propertyInfo.DeclaringType implements interfaceType before calling IsImplementationOf");

System\Data\Objects\EntityEntry.cs (135)

System\Data\Objects\FieldDescriptor.cs (1)

46System.Diagnostics.Debug.Assert(_fieldType != null, "FieldDescriptor's CLR type has unexpected value of null.");

System\Data\Objects\Internal\BaseEntityWrapper.cs (9)

47Debug.Assert(!(entity is IEntityWrapper), "Object is an IEntityWrapper instance instead of the raw entity."); 48Debug.Assert(entity != null, "Factory should ensure wrapped entity here is never null."); 71Debug.Assert(!(entity is IEntityWrapper), "Object is an IEntityWrapper instance instead of the raw entity."); 72Debug.Assert(entity != null, "Factory should ensure wrapped entity here is never null."); 114Debug.Assert(value == MergeOption.AppendOnly || value == MergeOption.NoTracking, "Merge option must be one of NoTracking or AppendOnly."); 149Debug.Assert(null != context, "context"); 161Debug.Assert(null != entitySet, "entitySet should not be null"); 162Debug.Assert(null != context, "context"); 163Debug.Assert(MergeOption.NoTracking == mergeOption ||

System\Data\Objects\Internal\ComplexTypeMaterializer.cs (22)

System\Data\Objects\Internal\EntityProxyFactory.cs (21)

130Debug.Assert(instance != null, "the instance should not be null"); 154Debug.Assert(ospaceEntityType != null, "ospaceEntityType must be non-null"); 155Debug.Assert(ospaceEntityType.DataSpace == DataSpace.OSpace, "ospaceEntityType.DataSpace must be OSpace"); 212Debug.Assert(ospaceEntityTypes != null, "ospaceEntityTypes must be non-null"); 223Debug.Assert(ospaceEntityType != null, "Null EntityType element reference present in enumeration."); 235Debug.Assert(s_TypeMapLock.IsUpgradeableReadLockHeld, "EntityProxyTypeInfo.TryCreateProxyType method was called without first acquiring an upgradeable read lock from s_TypeMapLock."); 277Debug.Assert(type != null, "type is null, was this intended?"); 309Debug.Assert(propertyInfo != null, "Null propertyInfo"); 348Debug.Assert(propertyInfo != null, "Null propertyInfo"); 391Debug.Assert(s_TypeMapLock.IsUpgradeableReadLockHeld, "EntityProxyTypeInfo.BuildType method was called without first acquiring an upgradeable read lock from s_TypeMapLock."); 461Debug.Assert(property != null, String.Format(CultureInfo.CurrentCulture, "Expected property {0} to be defined on proxy type {1}", member.Name, proxyType.FullName)); 464Debug.Assert(interceptorField != null, String.Format(CultureInfo.CurrentCulture, "Expected interceptor field for property {0} to be defined on proxy type {1}", member.Name, proxyType.FullName)); 498Debug.Assert(resetFKSetterFlagField != null, "Expected resetFKSetterFlagField to be defined on the proxy type."); 513Debug.Assert(getEntityWrapperDelegate != null, "entityWrapperDelegate must not be null"); 527Debug.Assert(wrappedEntityAsObject == null || wrappedEntityAsObject is IEntityWrapper, "wrappedEntityAsObject must be an IEntityWrapper"); 542Debug.Assert(compareByteArraysField != null, "Expected compareByteArraysField to be defined on the proxy type."); 599Debug.Assert(clrProperty != null, "clrProperty should have a value"); 605Debug.Assert(clrProperty != null, "clrProperty should have a value"); 801Debug.Assert(false, "Unable to find ScriptIgnoreAttribute type"); 1207Debug.Assert(member != null, "member is null"); 1586Debug.Assert(!(_canOverride && (_getObjectDataMethod == null || _serializationConstructor == null)), "Both GetObjectData method and Serialization Constructor must be present when proxy overrides ISerializable implementation.");

System\Data\Objects\Internal\EntityProxyTypeInfo.cs (4)

48Debug.Assert(proxyType != null, "proxyType must be non-null"); 81Debug.Assert(entityWrapperField != null, "entityWrapperField does not exist"); 198Debug.Assert(wrapper != null, "wrapper must be non-null"); 199Debug.Assert(wrapper.Entity != null, "proxy must be non-null");

System\Data\Objects\Internal\EntitySqlQueryBuilder.cs (15)

System\Data\Objects\Internal\EntitySqlQueryState.cs (3)

194Debug.Assert(queryExpression != null, "EntitySqlQueryState.Parse returned null expression?"); 250Debug.Assert(typeUsage != null, "typeUsage != null"); 265Debug.Assert(lambda.Variables == null || lambda.Variables.Count == 0, "lambda.Variables must be empty");

System\Data\Objects\Internal\EntityWrapper.cs (4)

173Debug.Assert(_changeTrackingStrategy != null, "Change tracking strategy cannot be null."); 174Debug.Assert(_keyStrategy != null, "Key strategy cannot be null."); 206Debug.Assert(_changeTrackingStrategy != null, "Change tracking strategy cannot be null."); 207Debug.Assert(_keyStrategy != null, "Key strategy cannot be null.");

System\Data\Objects\Internal\EntityWrapperFactory.cs (2)

51Debug.Assert(!(entity is IEntityWrapper), "Object is an IEntityWrapper instance instead of the raw entity."); 228Debug.Assert(!(entity is IEntityWrapper), "Object is an IEntityWrapper instance instead of the raw entity.");

System\Data\Objects\Internal\ForeignKeyFactory.cs (5)

46Debug.Assert(IsConceptualNullKey(conceptualNullKey), "The key supplied is not a null key"); 63Debug.Assert(originalKey != null, "Original key can not be null"); 81Debug.Assert(constraint.FromRole.Identity == relatedEnd.TargetRoleName, "Unexpected constraint role"); 115Debug.Assert(keyNames.Length == numValues, "Number of entity set key names does not match constraint names"); 128Debug.Assert(keyIndex >= 0 && keyIndex < numValues, "Could not find constraint prop name in entity set key names");

System\Data\Objects\Internal\LazyLoadBehavior.cs (5)

58Debug.Assert(member.BuiltInTypeKind == BuiltInTypeKind.NavigationProperty, "member should represent a navigation property"); 117Debug.Assert(ospaceEntityType.DataSpace == DataSpace.OSpace, "ospaceEntityType.DataSpace must be OSpace"); 127Debug.Assert(propertyInfo != null, "Should have found lazy loading property"); 166Debug.Assert(wrapperObject == null || wrapperObject is IEntityWrapper, "wrapperObject must be an IEntityWrapper"); 172Debug.Assert(relationshipManager != null, "relationshipManager should be non-null");

System\Data\Objects\Internal\LightweightEntityWrapper.cs (8)

System\Data\Objects\Internal\NullEntityWrapper.cs (1)

93Debug.Assert(false, "Method on NullEntityWrapper should not be called");

System\Data\Objects\Internal\ObjectFullSpanRewriter.cs (4)

55Debug.Assert(span != null, "Span cannot be null"); 56Debug.Assert(span.SpanList.Count > 0, "At least one span path is required"); 155Debug.Assert(retType != null, "Navigation property has non-Entity and non-Entity collection result type?"); 201Debug.Assert(relationship.AssociationEndMembers.Contains(property.ToEndMember.Name), "Association does not declare member referenced by Navigation property?");

System\Data\Objects\Internal\ObjectQueryExecutionPlan.cs (5)

39Debug.Assert(commandDefinition != null, "A command definition is required"); 40Debug.Assert(resultShaperFactory != null, "A result shaper factory is required"); 41Debug.Assert(resultType != null, "A result type is required"); 222Debug.Assert(context != null, "ObjectContext cannot be null"); 223Debug.Assert(query != null, "Command tree cannot be null");

System\Data\Objects\Internal\ObjectQueryState.cs (3)

315Debug.Assert(createMethod != null, "Unable to retrieve ObjectQueryState.CreateObjectQuery<> method?"); 330Debug.Assert(queryState != null, "Query state is required"); 331Debug.Assert(typeof(TResultType) == queryState.ElementType, "Element type mismatch");

System\Data\Objects\Internal\ObjectSpanRewriter.cs (6)

74Debug.Assert(rewriter.SpanIndex != null || tree.Query.ResultType.EdmEquals(newQuery.ResultType), "Query was rewritten for Span but no SpanIndex was created?"); 89Debug.Assert(toRewrite != null, "Expression to rewrite cannot be null"); 721Debug.Assert(originalNavigation != null, "originalNavigation cannot be null"); 722Debug.Assert(rewrittenNavigation != null, "rewrittenNavigation cannot be null"); 742Debug.Assert(TypeSemantics.IsCollectionType(expression.ResultType), "Non-collection input to projection?"); 756Debug.Assert(visitor._original != null && visitor._rewritten != null, "Expression was rewritten but no navigation was found?");

System\Data\Objects\Internal\PocoPropertyAccessorStrategy.cs (1)

158Debug.Assert(collection != null, "Collection is null");

System\Data\Objects\Internal\TransactionManager.cs (4)

59Debug.Assert(_originalMergeOption != null, "OriginalMergeOption used before being initialized"); 221Debug.Assert(this.PopulatedEntityReferences == null, "Expected promotion index to be null when begining tracking."); 222Debug.Assert(this.AlignedEntityReferences == null, "Expected promotion index to be null when begining tracking."); 344Debug.Assert(this.ProcessedEntities != null, "ProcessedEntities should not be null");

System\Data\Objects\ObjectContext.cs (54)

System\Data\Objects\ObjectParameter.cs (2)

163Debug.Assert(template != null, "Template ObjectParameter cannot be null"); 281Debug.Assert(null == _effectiveType, "Effective type should only be set once");

System\Data\Objects\ObjectQuery.cs (2)

71Debug.Assert(queryState != null, "ObjectQuery state cannot be null"); 165Debug.Assert(commandText != null && commandText.Length != 0, "Invalid Command Text returned");

System\Data\Objects\ObjectQuery_TResultType.cs (2)

134Debug.Assert(mergeAsMethod != null, "Could not retrieve ObjectQuery<T>.MergeAs method using reflection?"); 142Debug.Assert(includeSpanMethod != null, "Could not retrieve ObjectQuery<T>.IncludeSpan method using reflection?");

System\Data\Objects\ObjectSet.cs (2)

54Debug.Assert(entitySet != null, "ObjectSet constructor requires a non-null EntitySet"); 55Debug.Assert(context != null, "ObjectSet constructor requires a non-null ObjectContext");

System\Data\Objects\ObjectStateEntry.cs (3)

43Debug.Assert(cache != null, "cache cannot be null."); 357Debug.Assert(null != _cache, "null ObjectStateManager"); 358Debug.Assert(null != _entitySet, "null EntitySetBase");

System\Data\Objects\ObjectStateEntryBaseUpdatableDataRecord.cs (5)

49Debug.Assert(_cacheEntry != null, "CacheEntry is required."); 255Debug.Assert(_cacheEntry != null, "CacheEntry is required."); 310Debug.Assert(_cacheEntry != null, "CacheEntry is required."); 320Debug.Assert(_cacheEntry != null, "CacheEntry is required."); 537Debug.Assert(_cacheEntry != null, "CacheEntry is required.");

System\Data\Objects\ObjectStateEntryDbDataRecord.cs (6)

32Debug.Assert(!cacheEntry.IsKeyEntry, "Cannot create an ObjectStateEntryDbDataRecord for a key entry"); 43Debug.Assert(false, "A DbDataRecord cannot be created for an entity object that is in an added or detached state."); 50Debug.Assert(!cacheEntry.IsKeyEntry, "Cannot create an ObjectStateEntryDbDataRecord for a key entry"); 59Debug.Assert(false, "A DbDataRecord cannot be created for an entity object that is in an added or detached state."); 67Debug.Assert(_cacheEntry != null, "CacheEntry is required."); 262Debug.Assert(_cacheEntry != null, "CacheEntry is required.");

System\Data\Objects\ObjectStateEntryDbUpdatableDataRecord.cs (3)

28Debug.Assert(!cacheEntry.IsKeyEntry, "Cannot create an ObjectStateEntryDbUpdatableDataRecord for a key entry"); 36Debug.Assert(false, "A CurrentValueRecord cannot be created for an entity object that is in a deleted or detached state."); 51Debug.Assert(false, "A CurrentValueRecord cannot be created for an entity object that is in a deleted or detached state.");

System\Data\Objects\ObjectStateEntryOriginalDbUpdatableDataRecord.cs (5)

30Debug.Assert(!cacheEntry.IsKeyEntry, "Cannot create an ObjectStateEntryOriginalDbUpdatableDataRecord_Internal for a key entry"); 38Debug.Assert(false, "An OriginalValueRecord cannot be created for an object in an added or detached state."); 44Debug.Assert(!_cacheEntry.IsRelationship, "should not be relationship"); 49Debug.Assert(!_cacheEntry.IsRelationship, "should not be relationship"); 72Debug.Assert(!_cacheEntry.IsRelationship, "should not be relationship");

System\Data\Objects\ObjectStateManager.cs (140)

System\Data\Objects\ObjectStateManagerMetadata.cs (14)

System\Data\Objects\ObjectView.cs (2)

424Debug.Assert(((IList)this).Contains(value), "Value does not exist in view."); 494Debug.Assert(sender is TElement, "Entity should be of type TElement");

System\Data\Objects\ObjectViewFactory.cs (6)

127Debug.Assert(viewDataConstructor != null, "ObjectViewQueryResultData constructor not found. Please ensure constructor signature is correct."); 176Debug.Assert(clrElementType != null, "clrElementType has unexpected value of null."); 210Debug.Assert(viewDataConstructor != null, "ObjectViewEntityCollectionData constructor not found. Please ensure constructor signature is correct."); 236Debug.Assert(viewDataInterfaces.Length == 1, "Could not find IObjectViewData<T> interface definition for ObjectViewQueryResultData<T>."); 243Debug.Assert(viewConstructor != null, "ObjectView constructor not found. Please ensure constructor signature is correct."); 275Debug.Assert(typeUsage.EdmType.DataSpace == DataSpace.CSpace, String.Format(System.Globalization.CultureInfo.InvariantCulture, "Expected EdmType.DataSpace to be C-Space, but instead it is {0}.", typeUsage.EdmType.DataSpace.ToString()));

System\Data\Objects\ObjectViewListener.cs (2)

81Debug.Assert(entity != null, "Entity should not be null"); 106Debug.Assert(entity != null, "entity should not be null");

System\Data\Objects\ObjectViewQueryResultData.cs (4)

155Debug.Assert(_objectContext != null, "ObjectContext is null."); 172Debug.Assert(_objectContext != null, "ObjectContext is null."); 192Debug.Assert(_objectContext != null, "ObjectContext is null."); 233Debug.Assert(e.Action != CollectionChangeAction.Refresh, "Cache should never fire with refresh, it does not have clear");

System\Data\Objects\RelationshipEntry.cs (19)

38Debug.Assert(null != relationshipWrapper, "null RelationshipWrapper"); 39Debug.Assert(EntityState.Added == state || 84Debug.Assert(false, "RelationshipEntry cannot be in Modified state"); 131Debug.Assert(false, "EntityKey setter shouldn't be called for RelationshipEntry"); 242Debug.Assert(this.RelationshipWrapper.Key0 == this.Key1, "invalid relationship"); 373Debug.Assert(associationSet.ElementType.AssociationEndMembers[0].Name == associationMember.Name || 425Debug.Assert(null != value, "don't set wrapper to null"); 536Debug.Assert(relationshipManager != null, "Entity wrapper returned a null RelationshipManager"); 581Debug.Assert(false, "RelationshipEntry cannot be in Modified state"); 608Debug.Assert(requestedState != EntityState.Modified, "Invalid requested state for relationsihp"); 609Debug.Assert(this.State != EntityState.Modified, "Invalid initial state for relationsihp"); 634Debug.Assert(false, "Invalid requested state"); 658Debug.Assert(false, "Invalid requested state"); 692Debug.Assert(false, "Invalid requested state"); 697Debug.Assert(false, "Invalid entry state"); 707Debug.Assert(null != (object)entityKey, "null EntityKey"); 708Debug.Assert(entityKey.Equals(Key0) || entityKey.Equals(Key1), "EntityKey mismatch"); 714Debug.Assert(null != (object)entityKey, "null EntityKey"); 715Debug.Assert(entityKey.Equals(Key0) || entityKey.Equals(Key1), "EntityKey mismatch");

System\Data\Objects\RelationshipWrapper.cs (13)

24Debug.Assert(null != extent, "null RelationshipWrapper"); 25Debug.Assert(null != (object)key, "null key"); 34Debug.Assert(null != wrapper, "null RelationshipWrapper"); 35Debug.Assert((uint)ordinal <= 1u, "ordinal out of range"); 36Debug.Assert(null != (object)key, "null key2"); 54Debug.Assert(null != extent, "null AssociationSet"); 55Debug.Assert(null != (object)key0, "null key0"); 56Debug.Assert(null != (object)key1, "null key1"); 59Debug.Assert(extent.ElementType.AssociationEndMembers.Count == 2, "only 2 ends are supported"); 69Debug.Assert(extent.ElementType.AssociationEndMembers[1].Name == role1, "a)roleAndKey1 Name differs"); 75Debug.Assert(extent.ElementType.AssociationEndMembers[0].Name == role1, "b)roleAndKey1 Name differs"); 76Debug.Assert(extent.ElementType.AssociationEndMembers[1].Name == role0, "b)roleAndKey0 Name differs"); 89Debug.Assert(Key0 == key || Key1 == key, "didn't match a key");

System\Data\Objects\Span.cs (1)

271Debug.Assert(navigations.Count > 0, "Empty path found");

System\Data\Objects\SpanIndex.cs (6)

72Debug.Assert(spannedRowType != null, "Spanned RowType cannot be null"); 73Debug.Assert(originalRowType != null, "Original RowType cannot be null"); 74Debug.Assert(originalRowType.EdmType.BuiltInTypeKind == BuiltInTypeKind.RowType, "Original RowType must be a RowType"); 96Debug.Assert(spanRowType != null, "Span RowType cannot be null"); 107Debug.Assert(rowType != null, "Span row type cannot be null"); 108Debug.Assert(columnMap != null, "Span column map cannot be null");

System\Data\Query\InternalTrees\ColumnMap.cs (18)

System\Data\Query\InternalTrees\ColumnMapFactory.cs (6)

40Debug.Assert(!baseStructuralType.Abstract, "mapping loader must verify abstract types have explicit mapping"); 47Debug.Assert(null != baseEntityType, "We should have entity type here"); 87Debug.Assert(Helper.IsEntityType(edmType) || null == entitySet, "The specified non-null EntitySet is incompatible with the EDM type specified."); 117Debug.Assert(false, "unexpected edmType?"); 245Debug.Assert(keyOrdinal >= 0, "keyMember for entity is not found by name in the data reader?"); 249Debug.Assert(null != keyColumnMap, "keyMember for entity isn't in properties collection for the entity?");

System\Data\Query\InternalTrees\Command.cs (9)

379Debug.Assert(m_vars[id].VarType != VarType.NotValid, "The var has been replaced by a different var and is no longer valid."); 434Debug.Assert(oldVar != null, "oldVar != null"); 1368Debug.Assert(leftMap.Count == rightMap.Count, "VarMap count mismatch"); 1385Debug.Assert(leftMap.Count == rightMap.Count, "VarMap count mismatch"); 1401Debug.Assert(leftMap.Count == rightMap.Count, "VarMap count mismatch"); 1610Debug.Assert((inputVars.Count % inputNodes.Count == 0) && (varPerNode >= 1), "Inconsistent nodes/vars count:" + inputNodes.Count + "," + inputVars.Count); 1658Debug.Assert(inputNodes.Count == inputVars.Count, "Count mismatch:" + inputNodes.Count + "," + inputVars.Count); 1684Debug.Assert(inputNode.Op.IsRelOp, "Expected a RelOp. Found " + inputNode.Op.OpType); 1777Debug.Assert(commonType != null, "No common type for " + arg0.Op.Type + " and " + arg1.Op.Type);

System\Data\Query\InternalTrees\Dump.cs (1)

1008Debug.Assert(false, "need to special case enum->string: " + op.ToString());

System\Data\Query\InternalTrees\Metadata.cs (1)

87Debug.Assert(false, "keyMember not in columns?");

System\Data\Query\InternalTrees\NodeInfo.cs (3)

334Debug.Assert(m_maxRows >= m_minRows, "MaxRows less than MinRows?"); 409Debug.Assert(n.Op.IsScalarOp || n.Op.IsAncillaryOp, "not a supported optype"); 538Debug.Assert(nodeInfo.Keys.NoKeys, "UnnestOp should have no keys in all cases except TVFs mapped to entities.");

System\Data\Query\InternalTrees\OpCopier.cs (4)

448Debug.Assert(op.EntitySet == null, "op.EntitySet must be null for the constructor that hasn't been scoped yet."); 961Debug.Assert(false, "Unexpected SetOpType"); 1046Debug.Assert(op.Var.VarType == VarType.Computed, "Unexpected VarType"); 1088Debug.Assert(newColumnMap != null, "Coping of a physical project's columnMap did not return a SimpleCollectionColumnMap" );

System\Data\Query\InternalTrees\Ops.cs (1)

517Debug.Assert(type != null, "No type specified for ScalarOp");

System\Data\Query\InternalTrees\PhysicalOps.cs (1)

76Debug.Assert(null != columnMap, "null columnMap?");

System\Data\Query\InternalTrees\RelOps.cs (4)

484Debug.Assert(null != vars, "null vars?"); 485Debug.Assert(!vars.IsEmpty, "empty varlist?"); 578Debug.Assert(opType == OpType.Sort || opType == OpType.ConstrainedSort, "SortBaseOp OpType must be Sort or ConstrainedSort"); 695Debug.Assert(opType == OpType.GroupBy || opType == OpType.GroupByInto, "GroupByBaseOp OpType must be GroupBy or GroupByInto");

System\Data\Query\InternalTrees\Rule.cs (5)

50Debug.Assert(nodeProcessDelegate != null, "null process delegate"); 51Debug.Assert(opType != OpType.NotValid, "bad OpType"); 52Debug.Assert(opType != OpType.Leaf, "bad OpType - Leaf"); 154Debug.Assert(pattern != null, "null pattern"); 155Debug.Assert(pattern.Op != null, "null pattern Op");

System\Data\Query\InternalTrees\RuleProcessor.cs (2)

68Debug.Assert(newNode == currentNode, "Liar! This rule should have returned 'true'"); 96Debug.Assert(loopCount < 12, "endless loops?");

System\Data\Query\InternalTrees\ScalarOps.cs (9)

85Debug.Assert(value != null, "ConstantOp with a null value?"); 165Debug.Assert(value != null, "InternalConstantOp with a null value?"); 430Debug.Assert((property is EdmProperty) || (property is RelationshipEndMember) || (property is NavigationProperty), "Unexpected EdmMember type"); 999Debug.Assert(scoped || entitySet == null, "entitySet cann't be set of constructor isn't scoped"); 1000Debug.Assert(relProperties != null, "expected non-null list of rel-properties"); 1075Debug.Assert(!type.EdmType.Abstract, "cannot create new instance of abstract type"); 1076Debug.Assert(!TypeSemantics.IsEntityType(type), "cannot use this Op for entity construction"); 1120Debug.Assert(null != discriminatorMap, "null discriminator map"); 1202Debug.Assert(Object.ReferenceEquals(field.DeclaringType, this.Type.EdmType),

System\Data\Query\PlanCompiler\NominalTypeEliminator.cs (3)

920System.Diagnostics.Debug.Assert(varDefOp != null, "varDefOp != null"); 921System.Diagnostics.Debug.Assert(node != null, "node != null"); 1597System.Diagnostics.Debug.Assert(outerVarInfo.Kind == VarInfoKind.StructuredTypeVarInfo, "StructuredVarInfo expected");

System\Data\Query\PlanCompiler\TypeInfo.cs (1)

302Debug.Assert(result, "Should have thrown if the property was not found");

System\Data\Query\PlanCompiler\VarInfo.cs (3)

229System.Diagnostics.Debug.Assert(newVar != null, "newVar != null"); 314System.Diagnostics.Debug.Assert(v != null, "v != null"); 315System.Diagnostics.Debug.Assert(newVar != null, "newVar != null");

System\Data\Query\ResultAssembly\BridgeDataReader.cs (11)

80Debug.Assert(null != shaper, "null shaper?"); 81Debug.Assert(null != coordinatorFactory, "null coordinatorFactory?"); 82Debug.Assert(depth == 0 || nextResultShaperInfos == null, "Nested data readers should not have multiple result sets."); 112Debug.Assert(null != DefaultRecordState, "no default?"); 126Debug.Assert(storeDataReader != null, "null storeDataReaders?"); 127Debug.Assert(columnMap != null, "null columnMap?"); 128Debug.Assert(workspace != null, "null workspace?"); 137Debug.Assert(storeDataReader != null, "null storeDataReaders?"); 138Debug.Assert(columnMap != null, "null columnMap?"); 139Debug.Assert(workspace != null, "null workspace?"); 348Debug.Assert(DataRecord.Depth == 0, "Nested data readers should not have multiple result sets.");

System\Data\Query\ResultAssembly\BridgeDataRecord.cs (6)

92Debug.Assert(null != shaper, "null shaper?"); 146Debug.Assert(null == _currentNestedRecord, "didn't close the nested record?"); 147Debug.Assert(null == _currentNestedReader, "didn't close the nested reader?"); 153Debug.Assert(null != newSource, "hasData but null newSource?"); // this shouldn't happen... 201Debug.Assert(null != _source, "null _source?"); // we should have already called AssertReaderIsOpen. 226Debug.Assert(null != _source, "null _source?"); // we should have already called AssertReaderIsOpen.

System\Data\Spatial\DbGeography.cs (2)

30Debug.Assert(spatialServices != null, "Spatial services are required"); 31Debug.Assert(spatialProviderValue != null, "Provider value is required");

System\Data\Spatial\DbGeometry.cs (2)

30Debug.Assert(spatialServices != null, "Spatial services are required"); 31Debug.Assert(spatialProviderValue != null, "Provider value is required");

System\Data\Spatial\DefaultSpatialServices.cs (2)

70Debug.Assert(geographyValue != null, "Validate geographyValue is non-null before calling CheckCompatible"); 84Debug.Assert(geometryValue != null, "Validate geometryValue is non-null before calling CheckCompatible");

System\Data\Spatial\SpatialHelpers.cs (2)

35Debug.Assert(providerFactory != null, "GetProviderSpatialServices requires provider factory to have been initialized"); 39Debug.Assert(result != null, "DbProviderServices did not throw ProviderIncompatibleException for null IDbSpatialDataReader");

System\Data\SqlClient\SqlGen\DmlSqlGenerator.cs (5)

156Debug.Assert(!first, "if useGeneratedValuesVariable is true, it implies some columns do not have values"); 511Debug.Assert(expression.ExpressionKind == DbExpressionKind.Equals, 531Debug.Assert(propertyExpression.ExpressionKind == DbExpressionKind.Property, 540Debug.Assert(value.ExpressionKind == DbExpressionKind.Constant, 585Debug.Assert(_commandTree.CommandTreeKind == DbCommandTreeKind.Update, "did you add a new option?");

System\Data\SqlClient\SqlGen\Sql8ExpressionRewriter.cs (5)

49Debug.Assert(originalTree != null, "OriginalTree is null"); 234Debug.Assert(leftFlattenedProperties.Count == rightFlattenedProperties.Count, "The left and the right input to INTERSECT or EXCEPT have a different number of properties"); 235Debug.Assert(leftFlattenedProperties.Count != 0, "The inputs to INTERSECT or EXCEPT have no properties"); 301Debug.Assert(properties.Count != 0, "No nested properties when FlattenProperties called?"); 314Debug.Assert(TypeSemantics.IsEntityType(properties[i].TypeUsage) || TypeSemantics.IsRowType(properties[i].TypeUsage),

System\Data\SqlClient\SqlGen\SqlFunctionCallHandler.cs (19)

458Debug.Assert(functionExpression.Arguments.Count == 1, "FromText function should have text or text + srid arguments only"); 669Debug.Assert(!(isNiladicFunction && (0 < e.Arguments.Count)), "function attributed as NiladicFunction='true' in the provider manifest cannot have arguments"); 738Debug.Assert(handlers.ContainsKey(e.Function.Name), "Special handling should be called only for functions in the list of special functions"); 744Debug.Assert(spatialTypeKind == PrimitiveTypeKind.Geography || spatialTypeKind == PrimitiveTypeKind.Geometry, "Spatial function does not refer to a valid spatial primitive type kind?"); 769Debug.Assert(functionExpression.Function.Parameters.Count > 0 && Helper.IsSpatialType(functionExpression.Function.Parameters[0].TypeUsage), "Instance property function does not have instance parameter?"); 775Debug.Assert(functionExpression.Function.Parameters.Count > 0 && Helper.IsSpatialType(functionExpression.Function.Parameters[0].TypeUsage), "Instance method function does not have instance parameter?"); 799Debug.Assert(!isPropertyAccess || functionExpression.Arguments.Count == 1, "Property accessor instance functions should have only the single instance argument"); 840Debug.Assert(e.Arguments.Count > 0 && e.Arguments.Count <= 2, "There should be 1 or 2 arguments for operator"); 855Debug.Assert(_functionNameToOperatorDictionary.ContainsKey(e.Function.Name), "The function can not be mapped to an operator"); 903Debug.Assert(e.Arguments.Count > 0, "e.Arguments.Count > 0"); 989Debug.Assert(e.Arguments.Count == 1, "Canonical datepart functions should have exactly one argument"); 1108Debug.Assert(args.Count == (hasDatePart ? 3 : 0) + 3 + (hasTimeZonePart ? 1 : 0), "Invalid number of parameters for a date time creating function"); 1222Debug.Assert(isPrimitiveType, "Expecting primitive type as input parameter to TruncateTime"); 1235Debug.Assert(true, "Unexpected type to TruncateTime" + typeKind.ToString()); 1412Debug.Assert(e.Arguments.Count <= 2, "Round or truncate should have at most 2 arguments"); 1472Debug.Assert(e.Arguments.Count == 1, "Trim should have one argument"); 1555Debug.Assert(args.Count == 2, "Contains should have two arguments"); 1598Debug.Assert(args.Count == 2, "StartsWith should have two arguments"); 1642Debug.Assert(args.Count == 2, "EndsWith should have two arguments");

System\Data\SqlClient\SqlGen\SqlGenerator.cs (22)

436Debug.Assert(false, "Unknown command tree kind"); 444Debug.Assert(tree.EdmFunction != null, "DbFunctionCommandTree function cannot be null"); 496Debug.Assert(tree.Query != null, "DbQueryCommandTree Query cannot be null"); 525Debug.Assert(sqlStatement != null, "The outer most sql statment is null"); 592Debug.Assert(this.SqlVersion != SqlVersion.Sql8, "DbApplyExpression when translating for SQL Server 2000."); 971Debug.Assert(precision > 0, "Precision must be greater than zero"); 1218Debug.Assert(this.SqlVersion != SqlVersion.Sql8, "DbExceptExpression when translating for SQL Server 2000."); 1567Debug.Assert(this.SqlVersion != SqlVersion.Sql8, "DbIntersectExpression when translating for SQL Server 2000."); 1692Debug.Assert(e.Limit is DbConstantExpression || e.Limit is DbParameterReferenceExpression, "DbLimitExpression.Limit is of invalid expression type"); 1693Debug.Assert(!((this.SqlVersion == SqlVersion.Sql8) && (e.Limit is DbParameterReferenceExpression)), "DbLimitExpression.Limit is DbParameterReferenceExpression for SQL Server 2000."); 1842Debug.Assert(Helper.IsPrimitiveType(type.EdmType), "Type must be primitive type"); 2456Debug.Assert(this.SqlVersion != SqlVersion.Sql8, "DbSkipExpression when translating for SQL Server 2000."); 2458Debug.Assert(e.Count is DbConstantExpression || e.Count is DbParameterReferenceExpression, "DbSkipExpression.Count is of invalid expression type"); 3816Debug.Assert(type.EdmType.DataSpace == DataSpace.CSpace, "Type must be in cSpace"); 3824Debug.Assert(Helper.IsPrimitiveType(storeTypeUsage.EdmType), "Type must be primitive type"); 3840Debug.Assert(hasFacet, "Binary type did not have MaxLength facet"); 3849Debug.Assert(hasFacet, "String type did not have MaxLength facet"); 3870Debug.Assert(hasFacet, "decimal must have precision facet"); 3871Debug.Assert(decimalPrecision > 0, "decimal precision must be greater than zero"); 3873Debug.Assert(hasFacet, "decimal must have scale facet"); 3874Debug.Assert(decimalPrecision >= decimalScale, "decimalPrecision must be greater or equal to decimalScale"); 4228Debug.Assert(mappedType != null, "Could not get type usage for primitive type");

System\Data\SqlClient\SqlGen\SqlSelectClauseBuilder.cs (1)

54Debug.Assert(m_top == null, "SqlSelectStatement.Top has already been set");

System\Data\SqlClient\SqlProviderManifest.cs (5)

177Debug.Assert((this._version == SqlVersion.Sql8) || (this._version == SqlVersion.Sql9), "Found verion other than Sql 8, 9 or 10"); 480Debug.Assert(newPrimitiveTypeKind == PrimitiveTypeKind.String || newPrimitiveTypeKind == PrimitiveTypeKind.Binary, "at this point only string and binary types should be present"); 609Debug.Assert(tu.Facets[DbProviderManifest.MaxLengthFacetName].Description.IsConstant, "varbinary(max) is not constant!"); 651Debug.Assert(tu.Facets[DbProviderManifest.MaxLengthFacetName].Description.IsConstant, "NVarchar(max) is not constant!"); 680Debug.Assert(tu.Facets[DbProviderManifest.MaxLengthFacetName].Description.IsConstant, "varchar(max) is not constant!");

System\Data\SqlClient\SqlProviderServices.cs (5)

57Debug.Assert(providerManifest != null, "CreateCommandDefinition passed null provider manifest to CreateDbCommandDefinition?"); 58Debug.Assert(commandTree != null, "CreateCommandDefinition did not validate commandTree argument?"); 73Debug.Assert(storeMetadata.StoreProviderManifest != null, "StoreItemCollection has null StoreProviderManifest?"); 653Debug.Assert(type.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType && 687Debug.Assert(type.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType &&

System\Data\SqlClient\SqlProviderUtilities.cs (2)

87Debug.Assert(logFileName != null, "must specify log file with data file"); 368Debug.Assert(new[] { "nvarchar(max)", "varchar(max)", "varbinary(max)" }.Contains(typeName),

System\Data\SqlClient\SqlSpatialDataReader.cs (1)

87Debug.Assert(spatialType != null, "Ensure spatialType is non-null before calling CreateBinaryReadDelegate");

System\Data\SqlClient\SqlSpatialServices.cs (1)

40Debug.Assert(getSqlTypes != null, "Validate SqlTypes assembly delegate before constructing SqlSpatialServiceS");

System\Data\SqlClient\SqlSpatialServices.Generated.cs (111)

System\Data\SqlClient\SqlTypesAssembly.cs (19)

80Debug.Assert(prop != null, "Type '" + exp.Type.FullName + "' does not declare a public instance property with the name '" + propertyName + "'"); 159Debug.Assert(sqlGeog != null, "SqlGeography type was not properly retrieved?"); 160Debug.Assert(sqlGeom != null, "SqlGeometry type was not properly retrieved?"); 427Debug.Assert(wellKnownBinary != null, "Validate WKB before calling SqlTypesGeographyFromBinary"); 433Debug.Assert(wellKnownText != null, "Validate WKT before calling SqlTypesGeographyFromText"); 446Debug.Assert(wellKnownBinary != null, "Validate WKB before calling SqlTypesGeometryFromBinary"); 452Debug.Assert(wellKnownText != null, "Validate WKT before calling SqlTypesGeometryFromText"); 462Debug.Assert(spatialValue != null, "Ensure spatial value is non-null before calling GetSqlTypesSpatialValue"); 519Debug.Assert(spatialType != null, "Ensure spatialType is non-null before calling CreateStaticConstructorDelegate"); 523Debug.Assert(staticCtorMethod != null, "Could not find method '" + methodName + "' on type '" + spatialType.FullName + "'"); 524Debug.Assert(staticCtorMethod.GetParameters().Length == 2 && staticCtorMethod.GetParameters()[1].ParameterType == typeof(int), "Static constructor method on '" + spatialType.FullName + "' does not match static constructor pattern?"); 552Debug.Assert(toConvert.Type == typeof(System.Xml.XmlReader), "Argument to static constructor method was not byte[], string or XmlReader?"); 565Debug.Assert(sqlBytesType.Name == "SqlBytes", "byte[] argument used with non-SqlBytes static constructor method?"); 567Debug.Assert(byteArrayCtor != null, "SqlXml(System.IO.Stream) constructor not found?"); 575Debug.Assert(sqlCharsType.Name == "SqlChars", "String argument used with non-SqlChars static constructor method?"); 578Debug.Assert(sqlCharsFromSqlStringCtor != null, "SqlXml(System.IO.Stream) constructor not found?"); 587Debug.Assert(sqlStringType.Name == "SqlString", "String argument used with non-SqlString static constructor method?"); 597Debug.Assert(sqlXmlType.Name == "SqlXml", "Stream argument used with non-SqlXml static constructor method?"); 599Debug.Assert(readerCtor != null, "SqlXml(System.Xml.XmlReader) constructor not found?");

System\Data\SqlClient\SqlVersion.cs (2)

53System.Diagnostics.Debug.Assert(connection.State == ConnectionState.Open, "Expected an open connection"); 65System.Diagnostics.Debug.Assert(majorVersion == 8, "not version 8");