/// <summary> /// Sets the named sets database tables 1 general. /// </summary> /// <param name="model">The model.</param> /// <param name="table">The table.</param> private static void setNAMED_SETS_DATABASE_TABLES_1_GENERAL(Model model, List <Dictionary <string, string> > table) { foreach (Dictionary <string, string> tableRow in table) { TableSet tableSet = model.OutputSettings.FillItem(tableRow["DBNamedSet"]); tableSet.SortOrder = tableRow["SortOrder"]; tableSet.IsUnformatted = Adaptor.fromYesNo(tableRow["Unformatted"]); tableSet.ModeStart = Adaptor.toInteger(tableRow["ModeStart"]); string modeEnd = tableRow["ModeEnd"]; if (modeEnd.ToUpper() == "ALL") { tableSet.AllModesUsed = true; } else { tableSet.AllModesUsed = false; tableSet.ModeEnd = Adaptor.toInteger(modeEnd); } tableSet.BaseReactionXCoordinate = Adaptor.toDouble(tableRow["BaseReacX"]); tableSet.BaseReactionYCoordinate = Adaptor.toDouble(tableRow["BaseReacY"]); tableSet.BaseReactionZCoordinate = Adaptor.toDouble(tableRow["BaseReacZ"]); tableSet.ModalHistoryOutput = Enums.EnumLibrary.ConvertStringToEnumByDescription <eMultiStepResultsOutput>(tableRow["ModalHist"]); tableSet.DirectIntegrationHistoryOutput = Enums.EnumLibrary.ConvertStringToEnumByDescription <eMultiStepResultsOutput>(tableRow["DirectHist"]); tableSet.NonlinearStaticOutput = Enums.EnumLibrary.ConvertStringToEnumByDescription <eMultiStepResultsOutput>(tableRow["NLStatic"]); tableSet.MultiStepStaticOutput = Enums.EnumLibrary.ConvertStringToEnumByDescription <eMultiStepResultsOutput>(tableRow["Multistep"]); tableSet.LoadCombinationOutput = Enums.EnumLibrary.ConvertStringToEnumByDescription <eLoadCombinationOutput>(tableRow["Combo"]); tableSet.SteadyStateOutput = tableRow["Steady"]; tableSet.SteadyStateOutputOption = tableRow["SteadyOpt"]; tableSet.PowerSpectralDensityOption = tableRow["PSD"]; } }
public static TableSet <T> GetTable <T>(string file) where T : TableBase, new() { var tp = typeof(T); TableSet <T> t = null; object tab; if (sTables.TryGetValue(tp, out tab)) { t = tab as TableSet <T>; } if (t == null) { t = new TableSet <T>(); sTables[tp] = t; } if (!t.ContainsTable(file)) { var f = string.Format(fileFormat, file); var txt = AssetDatabase.LoadAssetAtPath <TextAsset>(f); if (txt != null) { var merge = TableSet <T> .LoadAsNew(file, txt.text); TableSet <T> .MergeTo(merge, t); } } return(t); }
public DbSyncProvider(TableSet tableSet) { this.tableSet = tableSet; sourceDb = new QueryRunner(tableSet.SourceConnectionStringName); destinationDB = new QueryRunner(tableSet.DestinationConnectionStringName); syncChangesData = new SyncChangesData(tableSet); }
public void QueryWithContainsAndComplexFunction() { // Arrange var names = new List <string> { Germany, Finland }; TableSet <Country> tableSet = GetTableSet(); Expression <Func <Country, bool> > hasName = x => names.Contains(x.Name); Expression <Func <Country, bool> > exists = x => x.IsExists && x.Population > 1000000; var filter = hasName.And(exists); // Act List <Country> result = tableSet.Where(filter).ToList(); // Assert Assert.NotNull(result); Assert.Equal(2, result.Count); List <string> resultNames = result.Select(p => p.Name).ToList(); Assert.Contains(Germany, resultNames); Assert.Contains(Finland, resultNames); }
public SyncStatusReport(TableSet tableSet) { this.tableSet = tableSet; sourceDB = new QueryRunner(tableSet.SourceConnectionStringName); destinationDB = new QueryRunner(tableSet.DestinationConnectionStringName); restClient = new RestClient(BaseUrl); }
public async Task UseQueryExpressionTwice() { // Arrange const int value = 1800; TableSet <Country> tableSet = GetTableSet(); // Act IQueryable <Country> queryTwoEntity = tableSet.Where( p => p.Formed > new DateTime(value, 1, 1) && (p.PresidentsCount < 10 || p.Population < 10000000 && p.PresidentsCount > 10 && p.IsExists)); IQueryable <Country> queryOneEntity = tableSet.Where(p => p.Name == Germany); Country result = await queryOneEntity.SingleAsync(); List <Country> results = await queryTwoEntity.ToListAsync(); // Assert Assert.NotNull(result); Assert.Equal(Germany, result.Name); Assert.Equal(2, results.Count); Assert.Contains(Finland, results.Select(p => p.Name)); Assert.Contains(Spain, results.Select(p => p.Name)); }
/// <summary> /// Sets the named sets database tables 2 selections. /// </summary> /// <param name="model">The model.</param> /// <param name="table">The table.</param> private static void setNAMED_SETS_DATABASE_TABLES_2_SELECTIONS(Model model, List <Dictionary <string, string> > table) { foreach (Dictionary <string, string> tableRow in table) { TableSet tableSet = model.OutputSettings.FillItem(tableRow["DBNamedSet"]); switch (tableRow["SelectType"]) { case "Table": tableSet.TableNames.Add(tableRow["Selection"]); break; case "LoadPattern": LoadPattern loadPattern = model.Loading.Patterns.FillItem(tableRow["Selection"]); tableSet.LoadPatterns.Add(loadPattern); break; case "LoadCase": LoadCase loadCase = model.Loading.Cases.FillItem(tableRow["Selection"]); tableSet.LoadCases.Add(loadCase); break; case "Combo": LoadCombination loadCombo = model.Loading.Combinations.FillItem(tableRow["Selection"]); tableSet.LoadCombinations.Add(loadCombo); break; } } }
public async Task AddOrUpdateEntitiesWithNullParameterAsync() { // Arrange Mock <ITableRequestExecutor <Country> > mock = MocksFactory.GetQueryExecutorMock <Country>(); CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet <Country>(tableClient) { RequestExecutor = mock.Object }; IEnumerable <Country> result = null; // Act try { result = await context.AddOrUpdateAsync((IEnumerable <Country>) null, CancellationToken.None); } catch (ArgumentNullException) { } // Assert Assert.Null(result); mock.Verify(executor => executor.ExecuteBatches(It.IsAny <IEnumerable <Country> >(), It.IsAny <Func <ITableEntity, TableOperation> >()), Times.Never()); }
public override string ToString() { var tableCount = TableSet.Count; var totalRowCount = TableSet.Sum(table => table.Rows.Count); return($"{Database} ; Total row count = {totalRowCount} ; Table count = {tableCount}"); }
public TableLoader(int id, string file, bool merge, TableSet <T> table, string folder, string extension) { mFile = file; mMerge = merge; mTable = table == null ? TableSet <T> .Instance : table; Identify = id;// TableSet<T>.HashTable(file); AssetPath = StringUtil.Concat(folder, file, extension); mTable.WaitForLoading(); }
/// <summary> /// 通用的分页方法(多条件) /// </summary> /// <param name="ts">TableSet</param> /// <param name="rpt">Repeater带分页控件</param> /// <typeparam name="TEntity">实体类</typeparam> public static List <TEntity> ToList <TEntity>(this TableSet <TEntity> ts, Repeater rpt) where TEntity : class, Core.Infrastructure.IEntity, new() { int recordCount; var lst = ts.ToList(rpt.PageSize, rpt.PageIndex, out recordCount); rpt.PageCount = recordCount; return(lst); }
public ContainsTests() { TableSet <Country> tableSet = GetTableSet(); tableSet.Add( new Country { Area = 357021, Continent = "Europe", TopSecretKey = new byte[] { 0xaa, 0xbb, 0xcc }, Formed = new DateTime(1871, 1, 18), Id = Guid.NewGuid(), IsExists = true, Name = Germany, Population = 81799600, PresidentsCount = 11 }); tableSet.Add( new Country { Area = 505992, Continent = "Europe", TopSecretKey = new byte[] { 0xaa, 0xbb, 0xcc }, Formed = new DateTime(1812, 1, 1), Id = Guid.NewGuid(), IsExists = false, Name = Spain, Population = 47190493, PresidentsCount = 8 }); tableSet.Add( new Country { Area = 674843, Continent = "Europe", TopSecretKey = new byte[] { 0xaa, 0xbb, 0xcc }, Formed = new DateTime(1792, 1, 1), Id = Guid.NewGuid(), IsExists = true, Name = France, Population = 65350000, PresidentsCount = 24 }); tableSet.Add( new Country { Area = 338424, Continent = "Europe", TopSecretKey = new byte[] { 0xaa, 0xbb, 0xcc }, Formed = new DateTime(1809, 3, 29), Id = Guid.NewGuid(), IsExists = true, Name = Finland, Population = 5421827, PresidentsCount = 12 }); }
public void CreateTableSetWithNullTableClientParameter() { TableSet <Country> context = null; // Act && Assert Assert.Throws <ArgumentNullException>(() => { context = new TableSet <Country>(null); }); Assert.Null(context); }
public void CreateTableSetWithNullTableClientParameter() { TableSet<Country> context = null; // Act && Assert Assert.Throws<ArgumentNullException>(() => { context = new TableSet<Country>(null); }); Assert.Null(context); }
public void CreateTableSetWithNullTableNameParameter() { CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); TableSet <Country> context = null; // Act && Assert Assert.Throws <ArgumentNullException>(() => { context = new TableSet <Country>(tableClient, null); }); Assert.Null(context); }
/// <summary> /// 事务 /// </summary> /// <param name="database">数据库执行</param> /// <param name="tableName">表名称</param> public TableContext(DbExecutor database, string tableName = null) : base(database, tableName) { if (string.IsNullOrWhiteSpace(tableName)) { Name = TableMapCache.GetMap <TEntity>().ClassInfo.Name; } TableSet = new TableSet <TEntity>(this); IsMergeCommand = true; Query = DbFactory.CreateQueryTable(this); }
public bool IsTableLoaded <T>(string file) where T : TableBase, new() { int id = TableSet <T> .HashTable(file); if (mTaskQueue.Contains(id) || TableSet <T> .Instance.ContainsTable(id)) { return(true); } return(false); }
public void CreateTableSetWithNullTableNameParameter() { CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); TableSet<Country> context = null; // Act && Assert Assert.Throws<ArgumentNullException>(() => { context = new TableSet<Country>(tableClient, null); }); Assert.Null(context); }
public DmmGameRankingTableClient(CloudStorageAccount storageAccount, string tableName) { this.storageAccount = storageAccount; this.tableName = tableName; var tableClient = storageAccount.CreateCloudTableClient(); table = new TableSet <DmmGameRankingEntity>(tableClient, tableName); table.CreateIfNotExists(); }
public void SingleWithoutResult() { // Arrange TableSet <Country> tableSet = GetTableSet(); Country result = null; // Act Assert.Throws <InvalidOperationException>(() => { result = tableSet.Single(p => p.Name == string.Empty); }); Assert.Null(result); }
public async Task SingleOrDefaultAsyncWithPredicateWithoutResult() { // Arrange TableSet <Country> tableSet = GetTableSet(); // Act Country entity = await tableSet.SingleOrDefaultAsync(p => p.Name == "none"); // Assert Assert.Null(entity); }
/// <summary> /// Initializes a new instance of the <see cref="MetadataRepository{TEntity, TPartitionKey, TRowKey}" /> class. /// </summary> /// <param name="cloudStorageAccount">The cloud storage account.</param> public MetadataRepository(IStorageAccountWrapper storageAccountWrapper) { Args.IsNotNull(() => storageAccountWrapper); cloudTableClient = storageAccountWrapper.CreateCloudTableClient(); cloudTableClient.DefaultRequestOptions.RetryPolicy = new ExponentialRetry(TimeSpan.FromSeconds(45), 5); var cloudTableName = typeof(TEntity).Name.Replace("Entity", String.Empty); tableSet = new TableSet <TEntity>(cloudTableClient, cloudTableName); }
public void FirstOrDefaultWithoutResult() { // Arrange TableSet <Country> tableSet = GetTableSet(); // Act Country result = tableSet.FirstOrDefault(p => p.Name == string.Empty); // Assert Assert.Null(result); }
public async Task UseFieldInQueryExpression() { // Arrange TableSet <LogEntry> tableSet = GetTableSet(); string message = string.Format(MessageTemplate, 2); // Act LogEntry result = await tableSet.FirstAsync(p => p.Message == message); // Assert Assert.Equal(result.Message, message); }
private static Tuple <List <T1>, List <T2> > BuildResult(TableSet result) { if (result.Count != 2) { throw new DataException($"Expected 2 tables but received {result.Count} tables"); } return(Tuple.Create( result[0].ToObjects <T1>().ToList(), result[1].ToObjects <T2>().ToList() )); }
public void SingleWithExpressionWithOneResult() { // Arrange TableSet <Country> tableSet = GetTableSet(); // Act Country result = tableSet.Single(p => p.Name == France); // Assert Assert.NotNull(result); Assert.Equal(France, result.Name); }
public void Single() { // Arrange TableSet <Country> tableSet = GetTableSet(); Country result = null; // Act Assert.Throws <InvalidOperationException>(() => result = tableSet.Single()); // Assert Assert.Null(result); }
public void SingleAfterWhereWithExpression() { // Arrange TableSet <Country> tableSet = GetTableSet(); // Act Country result = tableSet.Where(p => p.Population > 20000000).Single(p => p.Population < 30000000); // Assert Assert.NotNull(result); Assert.Equal(Yugoslavia, result.Name); }
public void SingleAfterWhereWithMultipleResult() { // Arrange TableSet <Country> tableSet = GetTableSet(); Country result = null; // Act Assert.Throws <InvalidOperationException>(() => result = tableSet.Where(p => p.Population > 20000000).Single()); // Assert Assert.Null(result); }
public void SingleAfterWhere() { // Arrange TableSet <Country> tableSet = GetTableSet(); // Act Country result = tableSet.Where(p => p.Population > 60000000).Single(); // Assert Assert.NotNull(result); Assert.Equal(France, result.Name); }
public void FirstWithExpressionWithMultipleResults() { // Arrange TableSet <Country> tableSet = GetTableSet(); // Act Country result = tableSet.First(p => p.Continent == Europe); // Assert Assert.NotNull(result); Assert.Equal(Finland, result.Name); }
public void CreateTableSetWithTableClientAndNameParameters() { // Arrange CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); const string tableName = "tableName"; // Act var context = new TableSet<Country>(tableClient, tableName); // Assert Assert.Equal(tableName, context.RequestExecutorFactory.CloudTable.Name); }
public void SingleWithExpressionWithMultipleResults() { // Arrange TableSet <Country> tableSet = GetTableSet(); Country result = null; // Act Assert.Throws <InvalidOperationException>(() => result = tableSet.Single(p => p.Continent == Europe)); // Assert Assert.Null(result); }
public void CreateTableSetWithTableClientParameter() { // Arrange CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); // Act var context = new TableSet<Country>(tableClient); // Assert Assert.Equal(typeof (Country).Name, context.RequestExecutorFactory.CloudTable.Name); Assert.Equal(ExecutionMode.Sequential, context.ExecutionMode); Assert.IsType<TableRequestSequentialExecutor<Country>>(context.RequestExecutor); }
public void RemoveEmptyCollection() { // Arrange Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>(); CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Country>(tableClient) { RequestExecutor = mock.Object }; var countries = new List<Country>(); // Act context.Remove(countries); }
public void SetTheSameExecutionMode() { // Arrange CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Country>(tableClient); var executor = context.RequestExecutor; // Act context.ExecutionMode = ExecutionMode.Sequential; // Assert Assert.Equal(ExecutionMode.Sequential, context.ExecutionMode); Assert.IsType<TableRequestSequentialExecutor<Country>>(context.RequestExecutor); Assert.Same(executor, context.RequestExecutor); }
public void RemoveEntitiesWithNullParameter() { // Arrange Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>(); CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Country>(tableClient) { RequestExecutor = mock.Object }; // Act Assert.Throws<ArgumentNullException>(() => context.Remove((IList<Country>) null)); // Assert mock.Verify(executor => executor.ExecuteBatches(It.IsAny<IList<Country>>(), It.IsAny<Func<ITableEntity, TableOperation>>()), Times.Never()); }
public async Task RemoveEntitiesAsync() { // Arrange Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>(); CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Country>(tableClient) { RequestExecutor = mock.Object }; IList<Country> countries = ObjectsFactory.GetCountries(); // Act await context.RemoveAsync(countries); // Assert mock.Verify(executor => executor.ExecuteBatchesWithoutResultAsync(countries, TableOperation.Delete, It.IsAny<CancellationToken>())); }
public void RemoveEntities() { // Arrange Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>(); CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Country>(tableClient) { RequestExecutor = mock.Object }; IList<Country> countries = ObjectsFactory.GetCountries(); // Act context.Remove(countries); // Assert mock.Verify(executor => executor.ExecuteBatchesWithoutResult(countries, TableOperation.Delete), Times.Once()); }
public void AddOrMergeEmptyCollection() { // Arrange Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>(); CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Country>(tableClient) { RequestExecutor = mock.Object }; var countries = new List<Country>(); // Act var result = context.AddOrMerge(countries); // Assert Assert.NotNull(result); Assert.Equal(countries, result); }
public void AddOrMergeEntitiesWithNullParameter() { // Arrange Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>(); CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Country>(tableClient) { RequestExecutor = mock.Object }; IEnumerable<Country> result = null; // Act Assert.Throws<ArgumentNullException>(() => { result = context.AddOrMerge((IEnumerable<Country>)null); }); // Assert Assert.Null(result); mock.Verify(executor => executor.ExecuteBatches(It.IsAny<IEnumerable<Country>>(), It.IsAny<Func<ITableEntity, TableOperation>>()), Times.Never()); }
public void AddOrMergeEntities() { // Arrange Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>(); CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Country>(tableClient) { RequestExecutor = mock.Object }; var countries = ObjectsFactory.GetCountries(); // Act var result = context.AddOrMerge(countries); // Assert Assert.NotNull(result); mock.Verify(executor => executor.ExecuteBatches(countries, TableOperation.InsertOrMerge), Times.Once()); Assert.Equal(countries, result); }
public async Task AddOrMergeEntityAsync() { // Arrange Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>(); CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Country>(tableClient) { RequestExecutor = mock.Object }; Country country = ObjectsFactory.GetCountry(); // Act Country result = await context.AddOrMergeAsync(country); // Assert Assert.NotNull(result); mock.Verify(executor => executor.ExecuteAsync(country, TableOperation.InsertOrMerge, It.IsAny<CancellationToken>())); Assert.Equal(country, result); }
public void AddEntity() { // Arrange Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>(); CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Country>(tableClient) { RequestExecutor = mock.Object }; Country country = ObjectsFactory.GetCountry(); // Act Country result = context.Add(country); // Assert Assert.NotNull(result); mock.Verify(executor => executor.Execute(country, TableOperation.Insert), Times.Once()); Assert.Equal(country, result); }
public void AddEntity_FluentMapping() { // Arrange Mock<ITableRequestExecutor<Address>> mock = MocksFactory.GetQueryExecutorMock<Address>(); CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Address>(tableClient) { RequestExecutor = mock.Object }; Address model = ObjectsFactory.GetAddress(); // Act Address result = context.Add(model); // Assert Assert.NotNull(result); mock.Verify(executor => executor.Execute(model, TableOperation.Insert), Times.Once()); Assert.Equal(model, result); }
static void TestTableInstance(int count = 1000000) { var table = new Table(); var type = typeof(TableSet<UserVO>); SpeedTest.ConsoleTime("手动创建", count, () => { var User = new TableSet<UserVO>(table, "User"); //table.Dispose(); }); SpeedTest.ConsoleTime("表达式树创建", count, () => { var po = (TableSet<UserVO>)CacheManger.CreateInstance(type, table, "User"); //table.Dispose(); //Expressions.CreateInstance(type); }); SpeedTest.ConsoleTime("反射创建", count, () => { var po = (TableSet<UserVO>)Activator.CreateInstance(type, table, "User"); //table.Dispose(); }); }
public async Task RemoveEntityWithNullParameterAsync() { // Arrange Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>(); CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Country>(tableClient) { RequestExecutor = mock.Object }; // Act try { await context.RemoveAsync((Country) null, CancellationToken.None); } catch (ArgumentNullException) { } // Assert mock.Verify(executor => executor.Execute(It.IsAny<Country>(), It.IsAny<Func<ITableEntity, TableOperation>>()), Times.Never()); }
public async Task AddOrMergeEntitiesWithNullParameterAsync() { // Arrange Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>(); CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Country>(tableClient) { RequestExecutor = mock.Object }; IEnumerable<Country> result = null; // Act try { result = await context.AddOrMergeAsync((IEnumerable<Country>)null, CancellationToken.None); } catch (ArgumentNullException) { } // Assert Assert.Null(result); mock.Verify(executor => executor.ExecuteBatches(It.IsAny<IEnumerable<Country>>(), It.IsAny<Func<ITableEntity, TableOperation>>()), Times.Never()); }
public async Task UpdateEntitiesAsync() { // Arrange Mock<ITableRequestExecutor<Country>> mock = MocksFactory.GetQueryExecutorMock<Country>(); CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Country>(tableClient) { RequestExecutor = mock.Object }; var countries = ObjectsFactory.GetCountries(); // Act var result = await context.UpdateAsync(countries); // Assert Assert.NotNull(result); mock.Verify(executor => executor.ExecuteBatchesAsync(countries, TableOperation.Replace, It.IsAny<CancellationToken>())); Assert.Equal(countries, result); }
public void ChangeTableSetExecutionMode() { // Arrange CloudTableClient tableClient = ObjectsFactory.GetCloudTableClient(); var context = new TableSet<Country>(tableClient); // Act context.ExecutionMode = ExecutionMode.Parallel; // Assert Assert.Equal(ExecutionMode.Parallel, context.ExecutionMode); Assert.IsType<TableRequestParallelExecutor<Country>>(context.RequestExecutor); }