public void CanReadTest()
{
ConcatenatedStream cStream = new ConcatenatedStream(streamSampleOne, streamSampleTwo, streamSampleThree);
int totalLength = sampleStreamSize * 2;
List<byte> output = new List<byte>();
while (cStream.CanRead)
{
output.Add((byte)cStream.ReadByte());
}
Assert.IsTrue(
output.Take(sampleStreamSize).SequenceEqual(streamSampleOne.ToArray()),
"First array does not match");
Assert.IsTrue(
output.Skip(sampleStreamSize).Take(sampleStreamSize).SequenceEqual(streamSampleTwo.ToArray()),
"Second array does not match");
Assert.IsTrue(
output.Skip(sampleStreamSize * 2).Take(sampleStreamSize).SequenceEqual(streamSampleThree.ToArray()),
"Third array does not match");
}
public void PlayExecutesSamePlayerOrderInEachRound()
{
var players = new[]
{
"Horse",
"Car",
"Hat"
};
var mockTurn = new Mock<ITurn>();
var game = new Game(players, mockTurn.Object, new GuidShuffler<String>());
var controller = new GameController(game);
var turnsTaken = new List<String>();
mockTurn.Setup(m => m.Take(It.IsAny<String>())).Callback((String p) => turnsTaken.Add(p));
controller.Play();
var lastRoundTurns = Enumerable.Empty<String>();
while (turnsTaken.Any())
{
var roundTurns = turnsTaken.Take(players.Count());
if (lastRoundTurns.Any())
{
for (var i = 0; i < lastRoundTurns.Count(); i++)
Assert.AreEqual(roundTurns.ElementAt(i), lastRoundTurns.ElementAt(i));
}
lastRoundTurns = roundTurns;
turnsTaken.RemoveRange(0, players.Count());
}
}
public void SupportVectorMachinePerformanceTest() {
ex = null;
var cv = new CrossValidation();
cv.Algorithm = new SupportVectorRegression();
var rand = new HeuristicLab.Random.MersenneTwister();
double[,] data = GenerateData(1000, rand);
List<string> variables = new List<string>() { "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10", "y" };
Dataset ds = new Dataset(variables, data);
cv.Problem.ProblemDataParameter.ActualValue = new RegressionProblemData(ds, variables.Take(10), variables.Last());
cv.Folds.Value = 5;
cv.SamplesStart.Value = 0;
cv.SamplesEnd.Value = 999;
cv.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(cv_ExceptionOccurred);
cv.Stopped += new EventHandler(cv_Stopped);
cv.Prepare();
cv.Start();
trigger.WaitOne();
if (ex != null) throw ex;
TestContext.WriteLine("Runtime: {0}", cv.ExecutionTime.ToString());
}
public void FillsInWithSongsWhenNotEnoughSpecified()
{
var all = new List<Song>(GetRandomSongs(75000));
var songs = new PlaylistGenerator(new List<ICriteriaCounter<Song>>())
.GeneratePlayList(all, 100, all.Take(50));
Assert.AreEqual(songs.Count(), 100);
}
public void Init()
{
var columns = new List<SysColumn>()
{
new SysColumn()
{
Name = "FirstColumn",
ColumnID = 1,
Identity = true,
Nullable = false,
SystemType = Core.Enumerations.SysType.Int
},
new SysColumn()
{
Name = "SecondColumn",
ColumnID = 1,
Identity = false,
Nullable = true,
SystemType = Core.Enumerations.SysType.VarChar,
MaxLength = 100
},
new SysColumn()
{
Name = "ThirdColumn",
ColumnID = 1,
Identity = false,
Nullable = false,
SystemType = Core.Enumerations.SysType.NVarChar,
MaxLength = 100
}
};
_sourceTable = new SysTable() { Name = "SourceTable" };
_sourceTable.Columns.AddRange(columns);
_targetTable = new SysTable() { Name = "TargetTable" };
_targetTable.Columns.AddRange(columns.Take(2));
}
public void ShouldListAllArtists()
{
// Arrange
List<string> artists = new List<string>
{
"1", "2", "3", "4"
};
Dictionary<string, IEnumerable<string>> genreArtistMap = new Dictionary<string, IEnumerable<string>>
{
{ "Pop", artists.Take(2) },
{ "Rock", artists.Skip(2).Take(2) }
};
IArtistsRepository repos = MockArtistsRepository.CreateMockRepository(genreArtistMap);
ArtistsController controller = new ArtistsController(repos);
// Act
ViewResult result = controller.AllArtists(1);
// Assert
Assert.AreEqual("", result.ViewName);
}
public void Generate_LongRunning2()
{
var start = default(ManualResetEvent);
var end = default(ManualResetEvent);
var s = new TestLongRunningScheduler(x => start = x, x => end = x);
var xs = Observable.Generate(0, _ => true, x => x + 1, x => x, s);
var lst = new List<int>();
var d = xs.Subscribe(x => { lst.Add(x); });
start.WaitOne();
while (lst.Count < 100)
;
d.Dispose();
end.WaitOne();
Assert.IsTrue(lst.Take(100).SequenceEqual(Enumerable.Range(0, 100)));
}
public void CreateAsync_IDisposable_Token()
{
var stopped = new ManualResetEvent(false);
var s = Disposable.Create(() => stopped.Set());
var e = new ManualResetEvent(false);
var xs = Observable.Create<int>((observer, ct) =>
{
return Task.Factory.StartNew(() =>
{
var i = 0;
while (!ct.IsCancellationRequested)
{
if (i++ == 10)
e.Set();
observer.OnNext(42);
}
return s;
});
});
var lst = new List<int>();
var d = xs.Subscribe(lst.Add);
e.WaitOne();
d.Dispose();
stopped.WaitOne();
Assert.IsTrue(lst.Take(10).SequenceEqual(Enumerable.Repeat(42, 10)));
}
public void TestSkipAndTakeWorksLikePs1()
{
var myList = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
var lastIndex = myList.Count - 1;
var myI = 7;
var left = myList.Take(myI).ToList();
var printMySkipTakeList = string.Join(",", left);
System.Diagnostics.Debug.WriteLine(printMySkipTakeList);
var right = myList.Skip(myI+1).Take(lastIndex).ToList();
left.AddRange(right);
printMySkipTakeList = string.Join(",", left);
System.Diagnostics.Debug.WriteLine(printMySkipTakeList);
}
public void TestListTake()
{
var l = new List<int> { 1, 2, 3, 4, 5 }.ToLiveList();
var t = l.Take(3.ToLiveConst()).ToIndependent();
t.States().Take(1).Check(
() => { },
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connecting);
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 1, 2, 3 }));
Assert.IsTrue(s.Delta == null);
});
t.States().Skip(1).Take(1).Check(
() => l.PublishInner.Insert(0, 0),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 0, 1, 2 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 0,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 0 },
},
},
new IndexNode<int>
{
Index = 3,
DenseIndex = 1,
Data = new ListIndexDelta<int>
{
DeleteItems = new[] { 3 },
},
},
}, new IndexNodeComparer<int>()));
});
t.States().Skip(1).Take(1).Check(
() => l.PublishInner.RemoveAt(0),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 1, 2, 3 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 0,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
DeleteItems = new[] { 0 },
},
},
new IndexNode<int>
{
Index = 2,
DenseIndex = 1,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 3 },
},
},
}, new IndexNodeComparer<int>()));
});
t.States().Skip(1).Take(1).Check(
() => l.PublishInner[1] = 99,
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 1, 99, 3 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 1,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 99 },
DeleteItems = new[] { 2 },
},
},
}, new IndexNodeComparer<int>()));
});
t.States().Skip(1).Take(1).Check(
() => l.PublishInner[2] = 88,
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 1, 99, 88 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 2,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 88 },
DeleteItems = new[] { 3 },
},
},
}, new IndexNodeComparer<int>()));
});
t.Check1(
() =>
{
l.PublishInner.Insert(0, -1);
l.PublishInner.Insert(3, 77);
},
state =>
{
var s = state.Skip(1).First();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { -1, 1, 99 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 0,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { -1 },
},
},
new IndexNode<int>
{
Index = 3,
DenseIndex = 1,
Data = new ListIndexDelta<int>
{
DeleteItems = new[] { 88 },
},
},
}, new IndexNodeComparer<int>()));
});
t.States().Skip(1).Take(1).Check(
() => l.PublishInner[3] = -1,
results => Assert.AreEqual(0, results.Count()));
}
public void GetDataByTestTypeIdPageableTest()
{
PagedResult<Test> expectedResult;
_repository
.Setup(it => it.GetDataByTestTypeIdPageable(It.IsAny<Int32>(), It.IsAny<String>(), It.IsAny<Int32>(), It.IsAny<Int32>()))
.Returns<Int32, String, Int32, Int32>((testTypeId, sortExpression, page, pageSize) =>
{
var query = _repositoryList.Where(x => x.TestTypeId==testTypeId);
switch (sortExpression)
{
case "Id":
query = new List<Test>(query.OrderBy(q => q.Id));
break;
case "TestTypeId":
query = new List<Test>(query.OrderBy(q => q.TestTypeId));
break;
case "ProjectId":
query = new List<Test>(query.OrderBy(q => q.ProjectId));
break;
case "GroupId":
query = new List<Test>(query.OrderBy(q => q.GroupId));
break;
case "Name":
query = new List<Test>(query.OrderBy(q => q.Name));
break;
case "TestValue":
query = new List<Test>(query.OrderBy(q => q.TestValue));
break;
case "IsActive":
query = new List<Test>(query.OrderBy(q => q.IsActive));
break; }
return query.Take(pageSize).Skip((page-1)*pageSize).ToList();
});
_repository
.Setup(it => it.GetDataByTestTypeIdRowCount(testTypeId))
.Returns(_repositoryList.Count);
var result = _target.GetDataByTestTypeIdPageable(TestTypeIdValue, "Id", 1, 2);
Assert.IsTrue(result.TryGetContentValue(out expectedResult));
Assert.AreEqual(_repositoryList.Where(x => x.TestTypeId==testTypeId).Take(2).ToList().Count, expectedResult.Results.Count);
Assert.AreEqual(_repositoryList.Where(x => x.TestTypeId==testTypeId).OrderBy(q => q.Id).FirstOrDefault().Id, expectedResult.Results.FirstOrDefault().Id);
}
public void GetConnectionsForProjectByProjectIdPageableTest()
{
PagedResult<Connection> expectedResult;
_repository
.Setup(it => it.GetConnectionsForProjectByProjectIdPageable(It.IsAny<Int32>(), It.IsAny<String>(), It.IsAny<Int32>(), It.IsAny<Int32>()))
.Returns<Int32, String, Int32, Int32>((projectId, sortExpression, page, pageSize) =>
{
var query = _repositoryList;
switch (sortExpression)
{
case "ConnectionId":
query = new List<Connection>(query.OrderBy(q => q.ConnectionId));
break;
case "Name":
query = new List<Connection>(query.OrderBy(q => q.Name));
break;
case "ConnectionString":
query = new List<Connection>(query.OrderBy(q => q.ConnectionString));
break;
case "IsActive":
query = new List<Connection>(query.OrderBy(q => q.IsActive));
break; }
return query.Take(pageSize).Skip((page-1)*pageSize).ToList();
});
_repository
.Setup(it => it.GetConnectionsForProjectByProjectIdRowCount(projectId))
.Returns(_repositoryList.Count);
var result = _target.GetConnectionsForProjectByProjectIdPageable(ProjectIdValue, "ConnectionId", 1, PageSizeValue);
Assert.IsTrue(result.TryGetContentValue(out expectedResult));
Assert.AreEqual(_repositoryList.Take(2).ToList().Count, expectedResult.Results.Count);
Assert.AreEqual(_repositoryList.OrderBy(q => q.ConnectionId).FirstOrDefault().ConnectionId, expectedResult.Results.FirstOrDefault().ConnectionId);
}
public void TestListTakeSimple()
{
var l = new List<int>().ToLiveList();
l.PublishInner.Connect(Enumerable.Empty<int>());
var t = l.Take(3.ToLiveConst()).ToIndependent();
t.States().Take(1).Check(
() => { },
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connecting);
Assert.IsTrue(s.Inner.SequenceEqual(new int[] { }));
Assert.IsTrue(s.Delta == null);
});
t.States().Skip(1).Take(1).Check(
() => l.PublishInner.Add(0),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 0 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 0,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 0 },
},
},
}, new IndexNodeComparer<int>()));
});
}
public void Search_Multiple_Results_Verify_Result()
{
var nonEmptyQuery = "tfs";
var expectedResults = new List<SearchResultItem>()
{
new SearchResultItem("101", "102", "description 113"),
new SearchResultItem("201", "202", "description 213"),
new SearchResultItem("301", "302", "description 313"),
new SearchResultItem("401", "402", "description 413"),
};
var output = new List<LocalViewwwJob>()
{
new LocalViewwwJob
{
RecordId = 101,
Creator = 102,
Created = DateTime.Now,
Session = 103,
StartTime = DateTime.Now,
Duration = 104,
Customer = 105,
Project = 106,
ProjectId = "107-108",
ProjectDescription = "project 109",
JobType = 110,
RateGroup = 111,
RateName = 112,
Description = "description 113",
Enabled = false,
ForceJobsEnabled = false
},
new LocalViewwwJob
{
RecordId = 201,
Creator = 202,
Created = DateTime.Now,
Session = 203,
StartTime = DateTime.Now,
Duration = 204,
Customer = 205,
Project = 206,
ProjectId = "207-208",
ProjectDescription = "project 209",
JobType = 210,
RateGroup = 211,
RateName = 212,
Description = "description 213",
Enabled = false,
ForceJobsEnabled = false
},
new LocalViewwwJob
{
RecordId = 301,
Creator = 302,
Created = DateTime.Now,
Session = 303,
StartTime = DateTime.Now,
Duration = 304,
Customer = 305,
Project = 306,
ProjectId = "307-308",
ProjectDescription = "project 309",
JobType = 310,
RateGroup = 311,
RateName = 312,
Description = "description 313",
Enabled = false,
ForceJobsEnabled = false
},
new LocalViewwwJob
{
RecordId = 401,
Creator = 402,
Created = DateTime.Now,
Session = 403,
StartTime = DateTime.Now,
Duration = 404,
Customer = 405,
Project = 406,
ProjectId = "407-408",
ProjectDescription = "project 409",
JobType = 410,
RateGroup = 411,
RateName = 412,
Description = "description 413",
Enabled = false,
ForceJobsEnabled = false
},
};
_mockDataAccessLayer1.Setup(x => x.Fetch(nonEmptyQuery)).Returns(output.Take(2).Select(job => job as IConvertableTo<SearchResultItem>).ToList());
_mockDataAccessLayer2.Setup(x => x.Fetch(nonEmptyQuery)).Returns(output.Skip(2).Select(job => job as IConvertableTo<SearchResultItem>).ToList());
List<SearchResultItem> results = _searchService.Search(nonEmptyQuery);
Assert.IsNotNull(results);
Assert.AreEqual(4, results.Count);
foreach (SearchResultItem expectedInResult in expectedResults)
{
Assert.IsTrue(results.Any(r => r.EmployeeKey == expectedInResult.EmployeeKey && r.EntryKey == expectedInResult.EntryKey && r.ProjectKey == expectedInResult.ProjectKey));
}
}
public void OcrParallelizationExperiment()
{
// Init Drive
var relpath = Path.Combine(Dir.OcrDirectory, Dir.OcrParallelizationTesting);
var drive = new Drive(relpath, Drive.Reason.Read);
var regs = drive.Files("reg").ToList();
var revs = drive.Files("rev").ToList();
// Sort to ensure correct pairing
regs.Sort();
revs.Sort();
// Concatenate and Recognize
var images = regs.Concat(revs).Select(path => new Bitmap(path)).ToList();
int revStart = regs.Count;
var datas = new List<OcrData>(OCR.ParallelRecognize(images, images.Count(), Accuracy.Low, "eng", true));
var regdata = datas.Take(revStart);
var revdata = datas.Skip(revStart);
var difference = regdata.Zip(revdata, (reg, rev) =>
{
Console.WriteLine("-----------------------------------------------");
Console.WriteLine(OCR.StripNewLine(reg.Text + " vs " + rev.Text));
Console.WriteLine(reg.Cost + " vs " + rev.Cost);
Console.WriteLine("Diff: " + (reg.Cost - rev.Cost));
Console.WriteLine("scantime: " + reg.ScanTime + "ms and " + rev.ScanTime + "ms");
Console.WriteLine();
return reg.Cost - rev.Cost;
}).ToList();
difference.ForEach(diff => Assert.IsTrue(diff < 0));
}
public void GetDataPageableTest()
{
PagedResult<AssertType> expectedResult;
_repository
.Setup(it => it.GetDataPageable(It.IsAny<String>(), It.IsAny<Int32>(), It.IsAny<Int32>()))
.Returns<String, Int32, Int32>((sortExpression, page, pageSize) =>
{
var query = _repositoryList;
switch (sortExpression)
{
case "Id":
query = new List<AssertType>(query.OrderBy(q => q.Id));
break;
case "Name":
query = new List<AssertType>(query.OrderBy(q => q.Name));
break; }
return query.Take(pageSize).Skip((page-1)*pageSize).ToList();
});
_repository
.Setup(it => it.GetRowCount())
.Returns(_repositoryList.Count);
var result = _target.GetDataPageable("Id", 1, 2);
Assert.IsTrue(result.TryGetContentValue(out expectedResult));
Assert.AreEqual(_repositoryList.Take(2).ToList().Count, expectedResult.Results.Count);
Assert.AreEqual(_repositoryList.OrderBy(q => q.Id).FirstOrDefault().Id, expectedResult.Results.FirstOrDefault().Id);
}
internal async Task TestAllReduceInternal()
{
var data = Enumerable.Range(1, 1000).Select(_ => Generator.GenerateShared(10)).ToList();
var stringSerializerCompiler = (VowpalWabbitSingleExampleSerializerCompiler<CbAdfShared>)
VowpalWabbitSerializerFactory.CreateSerializer<CbAdfShared>(new VowpalWabbitSettings { EnableStringExampleGeneration = true });
var stringSerializerAdfCompiler = (VowpalWabbitSingleExampleSerializerCompiler<CbAdfAction>)
VowpalWabbitSerializerFactory.CreateSerializer<CbAdfAction>(new VowpalWabbitSettings { EnableStringExampleGeneration = true });
var stringData = new List<List<string>>();
VowpalWabbitPerformanceStatistics statsExpected;
using (var spanningTree = new SpanningTreeClr())
{
spanningTree.Start();
using (var vw1 = new VowpalWabbit(new VowpalWabbitSettings(@"--total 2 --node 1 --unique_id 0 --span_server localhost --cb_adf --rank_all --interact xy") { EnableStringExampleGeneration = true }))
using (var vw2 = new VowpalWabbit(new VowpalWabbitSettings(@"--total 2 --node 0 --unique_id 0 --span_server localhost --cb_adf --rank_all --interact xy") { EnableStringExampleGeneration = true } ))
{
var stringSerializer = stringSerializerCompiler.Func(vw1);
var stringSerializerAdf = stringSerializerAdfCompiler.Func(vw1);
// serialize
foreach (var d in data)
{
var block = new List<string>();
using (var context = new VowpalWabbitMarshalContext(vw1))
{
stringSerializer(context, d.Item1, SharedLabel.Instance);
block.Add(context.ToString());
}
block.AddRange(d.Item2.Select((a, i) =>
{
using (var context = new VowpalWabbitMarshalContext(vw1))
{
stringSerializerAdf(context, a, i == d.Item3.Action ? d.Item3 : null);
return context.ToString();
}
}));
stringData.Add(block);
}
await Task.WhenAll(
Task.Factory.StartNew(() => Ingest(vw1, stringData.Take(500))),
Task.Factory.StartNew(() => Ingest(vw2, stringData.Skip(500))));
vw1.SaveModel("expected.1.model");
vw2.SaveModel("expected.2.model");
statsExpected = vw1.PerformanceStatistics;
}
}
// skip header
var expected1Model = File.ReadAllBytes("expected.1.model").Skip(0x15).ToList();
var expected2Model = File.ReadAllBytes("expected.2.model").Skip(0x15).ToList();
var settings = new VowpalWabbitSettings("--cb_adf --rank_all --interact xy")
{
ParallelOptions = new ParallelOptions
{
MaxDegreeOfParallelism = 2
},
ExampleCountPerRun = 2000,
ExampleDistribution = VowpalWabbitExampleDistribution.RoundRobin
};
using (var vw = new VowpalWabbitThreadedLearning(settings))
{
await Task.WhenAll(
Task.Factory.StartNew(() => Ingest(vw, stringData.Take(500))),
Task.Factory.StartNew(() => Ingest(vw, stringData.Skip(500))));
// important to enqueue the request before Complete() is called
var statsTask = vw.PerformanceStatistics;
var modelSave = vw.SaveModel("actual.model");
await vw.Complete();
var statsActual = await statsTask;
VWTestHelper.AssertEqual(statsExpected, statsActual);
await modelSave;
// skip header
var actualModel = File.ReadAllBytes("actual.model").Skip(0x15).ToList();
CollectionAssert.AreEqual(expected1Model, actualModel);
CollectionAssert.AreEqual(expected2Model, actualModel);
}
using (var vw = new VowpalWabbitThreadedLearning(settings))
{
var vwManaged = vw.Create<CbAdfShared, CbAdfAction>();
await Task.WhenAll(
Task.Factory.StartNew(() => Ingest(vwManaged, data.Take(500))),
Task.Factory.StartNew(() => Ingest(vwManaged, data.Skip(500))));
// important to enqueue the request before Complete() is called
var statsTask = vw.PerformanceStatistics;
var modelSave = vw.SaveModel("actual.managed.model");
await vw.Complete();
var statsActual = await statsTask;
VWTestHelper.AssertEqual(statsExpected, statsActual);
await modelSave;
// skip header
var actualModel = File.ReadAllBytes("actual.managed.model").Skip(0x15).ToList();
CollectionAssert.AreEqual(expected1Model, actualModel);
CollectionAssert.AreEqual(expected2Model, actualModel);
}
}
public void TestListTakeComplex()
{
var l = new List<int> { -1, -2, -3, -4, -5 }.ToLiveList();
var t = l.Take(3.ToLiveConst()).ToIndependent();
t.Check1(
() => Enumerable.Range(0, 5).ForEach(i => l.PublishInner.Insert(i, 100 + i)),
state =>
{
var s = state.Skip(1).First();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 100, 101, 102 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 0,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 100, 101, 102 },
DeleteItems = new[] { -1, -2, -3 },
},
},
}, new IndexNodeComparer<int>()));
});
l = new List<int> { -1, -2, -3, -4, -5 }.ToLiveList();
t = l.Take(5.ToLiveConst()).ToIndependent();
t.Check1(
() =>
{
l.PublishInner.Insert(1, 100);
l.PublishInner.Insert(3, 200);
l.PublishInner.Insert(5, 300);
l.PublishInner.Insert(7, 400);
},
state =>
{
var s = state.Skip(1).First();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { -1, 100, -2, 200, -3 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 1,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 100 },
},
},
new IndexNode<int>
{
Index = 3,
DenseIndex = 1,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 200 },
},
},
new IndexNode<int>
{
Index = 5,
DenseIndex = 2,
Data = new ListIndexDelta<int>
{
DeleteItems = new[] { -4, -5 },
},
},
}, new IndexNodeComparer<int>()));
});
l = new List<int> { -1, -2, -3, -4, -5 }.ToLiveList();
t = l.Take(5.ToLiveConst()).ToIndependent();
t.Check1(
() =>
{
l.PublishInner.Insert(1, 100);
l.PublishInner.Insert(3, 200);
l.PublishInner.RemoveAt(4);
l.PublishInner.Insert(5, 300);
l.PublishInner.Insert(7, 400);
},
state =>
{
var s = state.Skip(1).First();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { -1, 100, -2, 200, -4 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 1,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 100 },
},
},
new IndexNode<int>
{
Index = 3,
DenseIndex = 1,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 200 },
DeleteItems = new[] { -3 },
},
},
new IndexNode<int>
{
Index = 5,
DenseIndex = 2,
Data = new ListIndexDelta<int>
{
DeleteItems = new[] { -5 },
},
},
}, new IndexNodeComparer<int>()));
});
}
public void GetPaginationTest()
{
for (int i = 0; i < 20; i++)
{
List<int> items = new List<int>();
for (int j = 0; j < i; j++)
{
items.Add(j);
}
for (int resultsPerPage = 1; resultsPerPage < 21; resultsPerPage++)
{
var pageNumber = 0;
var page = items.GetPagination(resultsPerPage, ref pageNumber);
Assert.IsTrue(page.Count <= resultsPerPage);
Assert.IsTrue(page.IsEqualOrdered(items.Take(resultsPerPage).ToList()));
pageNumber = 99; // last page
page = items.GetPagination(resultsPerPage, ref pageNumber);
Assert.AreNotEqual(pageNumber, 99, i + " / " + resultsPerPage);
Assert.IsTrue(page.Count <= resultsPerPage);
if (items.Count > 0)
{
Assert.IsTrue(page.Count > 0, i + " / " + resultsPerPage);
Assert.IsTrue(page.IsEqualOrdered(items.Skip(items.Count - page.Count).Take(page.Count).ToList()));
}
}
}
}
public void Take()
{
// arrange
List<String> list = new List<String>() { "Backbone", "Angular", "React" };
// act
List<String> actual = list.Take(2).ToList();
List<String> actualOver = list.Take(4).ToList();
// assert
Assert.AreEqual(2, actual.Count());
Assert.AreEqual("Backbone", actual[0]);
Assert.AreEqual("Angular", actual[1]);
Assert.AreEqual(3, actualOver.Count());
Assert.AreEqual("React", actualOver[2]);
}
public void TestLinqExpr()
{
var A = new Dictionary<string, List<string>>
{
{"dbo.Table00", new List<string> {"column10", "column11", "column12", "column00"}}
};
var B = new Dictionary<string, List<string>>
{
{"dbo.Table10", new List<string> {"column10", "column11", "column02"}}
};
System.Diagnostics.Debug.WriteLine("Union");
var union = A.SelectMany(x => x.Value).Union(B.SelectMany(y => y.Value));
foreach (var r in union)
System.Diagnostics.Debug.WriteLine(r);
System.Diagnostics.Debug.WriteLine("");
System.Diagnostics.Debug.WriteLine("Intesect");
var intersect = A.SelectMany(x => x.Value).Intersect(B.SelectMany(y => y.Value));
foreach(var r in intersect)
System.Diagnostics.Debug.WriteLine(r);
System.Diagnostics.Debug.WriteLine("");
System.Diagnostics.Debug.WriteLine("Set Difference");
var setDiff = A.SelectMany(x => x.Value).Except(B.SelectMany(y => y.Value));
foreach(var r in setDiff)
System.Diagnostics.Debug.WriteLine(r);
System.Diagnostics.Debug.WriteLine("");
System.Diagnostics.Debug.WriteLine("Symetric Difference");
var symetricDiff =
A.SelectMany(x => x.Value)
.Except(B.SelectMany(y => y.Value))
.Union(B.SelectMany(y => y.Value).Except(A.SelectMany(x => x.Value)));
foreach(var r in symetricDiff)
System.Diagnostics.Debug.WriteLine(r);
System.Diagnostics.Debug.WriteLine("");
var Alist = new List<string> {"column10", "column11", "column12", "column00"};
var BList = new List<string> {"column10", "column11", "column02"};
var simpleListSetDiff = Alist.Select(x => x).Except(BList.Select(y => y)).ToList();
System.Diagnostics.Debug.WriteLine("Set Difference (on simple lists)");
foreach(var li in simpleListSetDiff)
System.Diagnostics.Debug.WriteLine(li);
//powershell'esque array splice
var myList = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,17 };
var lastIndex = myList.Count - 1;
var left = myList.Take(16).ToList();
var right = myList.Skip(16).Take(myList.Count).ToList();
foreach(var dk in right)
System.Diagnostics.Debug.WriteLine(dk);
}
public void BindingWorkflow_DiscoverProjects_OutputsExcludedProjects()
{
// Setup
ThreadHelper.SetCurrentThreadAsUIThread();
var controller = new ConfigurableProgressController();
var progressEvents = new ConfigurableProgressStepExecutionEvents();
List<Project> projects = new List<Project>();
for (int i = 0; i < 4; i++)
{
projects.Add(new ProjectMock($"cs{i}.csproj"));
}
this.projectSystemHelper.FilteredProjects = projects.Take(2);
this.projectSystemHelper.Projects = projects;
var testSubject = this.CreateTestSubject();
// Act
testSubject.DiscoverProjects(controller, progressEvents);
// Verify
this.outputWindowPane.AssertOutputStrings(1);
this.outputWindowPane.AssertMessageContainsAllWordsCaseSensitive(0, new[] { projects[2].UniqueName, projects[3].UniqueName });
}
public void TestListTakeComplex2()
{
var l = new List<int>().ToLiveList();
var t = l.Take(3.ToLiveConst()).ToIndependent();
t.Check1(
() =>
{
l.PublishInner.Insert(0, 1);
l.PublishInner.Insert(1, 2);
},
state =>
{
var s = state.Skip(1).First();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 1, 2 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 0,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 1, 2 },
},
},
}, new IndexNodeComparer<int>()));
});
t.Check1(
() =>
{
l.PublishInner.RemoveAt(0);
},
state =>
{
var s = state.Skip(1).First();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 2 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 0,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
DeleteItems = new[] { 1 },
},
},
}, new IndexNodeComparer<int>()));
});
t.Check1(
() =>
{
l.PublishInner.Insert(1, 3);
},
state =>
{
var s = state.Skip(1).First();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 2, 3 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 1,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 3 },
},
},
}, new IndexNodeComparer<int>()));
});
}
