protected void ApplyDefaultColumnNamesMapping(DatabaseSchema dbSchema, AbstractCollection collection, bool binaryToAttachment) { var tableSchema = dbSchema.Tables.First(x => x.Schema == collection.SourceTableSchema && x.TableName == collection.SourceTableName); var specialColumns = dbSchema.FindSpecialColumns(collection.SourceTableSchema, collection.SourceTableName); collection.ColumnsMapping = tableSchema.Columns .Where(x => specialColumns.Contains(x.Name) == false && (binaryToAttachment ? x.Type != ColumnType.Binary : true)) .Select(c => (c.Name, c.Name.First().ToString().ToUpper() + c.Name.Substring(1))) .ToDictionary(x => x.Name, x => x.Item2); collection.AttachmentNameMapping = tableSchema.Columns .Where(x => binaryToAttachment ? x.Type == ColumnType.Binary : false) .Select(c => (c.Name, c.Name.First().ToString().ToUpper() + c.Name.Substring(1))) .ToDictionary(x => x.Name, x => x.Item2); if (collection is CollectionWithReferences collectionWithRefs) { if (collectionWithRefs.LinkedCollections != null) { foreach (var linkedCollection in collectionWithRefs.LinkedCollections) { ApplyDefaultColumnNamesMapping(dbSchema, linkedCollection, binaryToAttachment); } } if (collectionWithRefs.NestedCollections != null) { foreach (var embeddedCollection in collectionWithRefs.NestedCollections) { ApplyDefaultColumnNamesMapping(dbSchema, embeddedCollection, binaryToAttachment); } } } }
private void CheckOnAbsentFalsePositive(int hashId, int numInsertions, RetouchedBloomFilter filter, TestBloomFilters.Digits digits, short removeSchema) { AbstractCollection <Key> falsePositives = FalsePositiveUnder1000[hashId]; if (falsePositives == null) { NUnit.Framework.Assert.Fail(string.Format("false positives for hash %d not founded" , hashId)); } filter.AddFalsePositive(falsePositives); for (int i = digits.GetStart(); i < numInsertions; i += 2) { filter.Add(new Key(Runtime.GetBytesForString(Extensions.ToString( i)))); } foreach (Key key in falsePositives) { filter.SelectiveClearing(key, removeSchema); } for (int i_1 = 1 - digits.GetStart(); i_1 < numInsertions; i_1 += 2) { NUnit.Framework.Assert.IsFalse(" testRetouchedBloomFilterAddFalsePositive error " + i_1, filter.MembershipTest(new Key(Runtime.GetBytesForString(Extensions.ToString (i_1))))); } }
public TableReference FindReference(AbstractCollection collection, List <string> columns) { return(References.FirstOrDefault(x => x.Table == collection.SourceTableName && x.Schema == collection.SourceTableSchema && EnumerableExtension.ContentEquals(x.Columns, columns))); }
/*------------- assertQueryResults ----------------*/ /** * Creates a query given the expression that is to be evaluated, then * asserts its result is equal to the evaluation of the given * <code>expectedResultExpression</code>. * <p> * If either the expected result or the expression result is a double, we'll * compare the two with a margin of 0.001. * </p> * * @param expectedResult * Object with which the query's result is to be compared. * @param expression * Expression that is to be evaluated. Note that we'll use * {@link EClass} as this expression's context. */ /* * public Object assertQueryResults(Object context, @NonNull String expectedResultExpression, @NonNull String expression){ * try * { * Object expectedResultQuery = evaluateLocal(context, expectedResultExpression); * Object result = assertQueryEquals(context, expectedResultQuery, expression); * PivotTestSuite.appendLog(testName, context, expression, null, expectedResultExpression, null); * return result; * } * catch (Exception e) * { * PivotTestSuite.failOn(expectedResultExpression, e); * return null; * } * } */ /* * public void assertQueryResults<T>(Collection<object> expectedResult, Collection<object> actualResult) * { * CollectionAssert.AreEqual(expectedResult as ICollection, actualResult as ICollection); * } * * public void assertQueryResults<T>(Bag<T> expectedResult, Sequence<T> actualResult) * { * CollectionAssert.AreEqual(expectedResult, actualResult); * }*/ /* * public void assertQueryResults<T>(Bag<T> expectedResult, Bag<T> actualResult){ * CollectionAssert.AreEqual(expectedResult, actualResult); * } * * public void assertQueryResults<T>(Bag<T> expectedResult, Sequence<T> actualResult) * { * CollectionAssert.AreEqual(expectedResult, actualResult); * } * * public void assertQueryResults<T>(Set<T> expectedResult, Set<T> actualResult){ * CollectionAssert.AreEqual(expectedResult, actualResult); * } * * public void assertQueryResults<T>(Sequence<T> expectedResult, Sequence<T> actualResult){ * CollectionAssert.AreEquivalent(expectedResult, actualResult); * } * * public void assertQueryResults<T>(OrderedSet<T> expectedResult, OrderedSet<T> actualResult){ * CollectionAssert.AreEquivalent(expectedResult, actualResult); * } */ public void assertQueryResults <T>(AbstractCollection <T> expectedResult, AbstractCollection <T> actualResult) { CollectionAssert.AreEqual(expectedResult, actualResult); }
/*------------- assertResultContainsAll ----------------*/ /** * Creates a query given the expression that is to be evaluated, then * asserts its result contains all elements included in * <code>expectedResult</code>. * * @param expectedResultExpression * Expression which is to be evaluated to determine the expected * result. * @param expression * Expression that is to be evaluated. Note that we'll use * {@link EClass} as this expression's context. */ /* * public Object assertResultContainsAll(Object context, @NonNull String expectedResultExpression, @NonNull String expression){ * try { * Object expectedResultQuery = evaluateLocal(null, expectedResultExpression); * TestCase.assertTrue(expectedResultQuery instanceof CollectionValue); * @SuppressWarnings("null") * Object result = assertResultContainsAll(context, (CollectionValue) expectedResultQuery, expression); * return result; * } catch (Exception e) { * PivotTestSuite.failOn(expectedResultExpression, e); * return null; * } * } */ public void assertResultContainsAll <T>(AbstractCollection <T> expected, AbstractCollection <T> actual) { CollectionAssert.AreEqual(expected, actual); }
public void assertQueryEquals <T>(AbstractCollection <T> expected, AbstractCollection <T> actual) { CollectionAssert.AreEqual(expected, actual); }