public void Init(Rect rect, BackendData backendData)
{
if (this.m_TreeView == null)
{
ITreeViewDataSource source;
this.m_BackendData = backendData;
TreeViewState treeViewState = new TreeViewState {
columnWidths = new float[] { 250f, 90f, 93f, 98f, 74f, 78f }
};
this.m_TreeView = new TreeView(this.m_EditorWindow, treeViewState);
ITreeViewGUI gui = new TestGUI(this.m_TreeView);
ITreeViewDragging dragging = new TestDragging(this.m_TreeView, this.m_BackendData);
if (this.m_Lazy)
{
source = new LazyTestDataSource(this.m_TreeView, this.m_BackendData);
}
else
{
source = new TestDataSource(this.m_TreeView, this.m_BackendData);
}
this.m_TreeView.Init(rect, source, gui, dragging);
this.m_ColumnHeader = new TreeViewColumnHeader();
this.m_ColumnHeader.columnWidths = treeViewState.columnWidths;
this.m_ColumnHeader.minColumnWidth = 30f;
this.m_ColumnHeader.columnRenderer = (Action<int, Rect>) Delegate.Combine(this.m_ColumnHeader.columnRenderer, new Action<int, Rect>(this.OnColumnRenderer));
}
}
public void DataSourceListIndexer ()
{
var source = new TestDataSource ();
IDataSource s = source;
source.DataItems.Add (new DataItem ("Foo", "Bar"));
Assert.AreEqual ("Bar", s["Foo"]);
Assert.AreEqual ("Bar", s.Data[0].Value);
}
public TreeViewTestWithCustomHeight(EditorWindow editorWindow, BackendData backendData, Rect rect)
{
this.m_BackendData = backendData;
TreeViewState treeViewState = new TreeViewState();
this.m_TreeView = new TreeViewController(editorWindow, treeViewState);
TestGUICustomItemHeights gui = new TestGUICustomItemHeights(this.m_TreeView);
TestDragging dragging = new TestDragging(this.m_TreeView, this.m_BackendData);
TestDataSource data = new TestDataSource(this.m_TreeView, this.m_BackendData);
data.onVisibleRowsChanged = (Action) Delegate.Combine(data.onVisibleRowsChanged, new Action(gui, (IntPtr) this.CalculateRowRects));
this.m_TreeView.Init(rect, data, gui, dragging);
data.SetExpanded(data.root, true);
}
public void RunDataDrivenTestsGivesTestResultAsPassedWhenTestMethodPasses()
{
this.testContextImplementation = new TestContextImplementation(this.testMethod.Object, new System.IO.StringWriter(), this.properties);
TestFrameworkV2.DataSourceAttribute dataSourceAttribute = new TestFrameworkV2.DataSourceAttribute(
"Microsoft.VisualStudio.TestTools.DataSource.XML", "DataTestSourceFile.xml", "settings", TestFrameworkV2.DataAccessMethod.Sequential);
this.mockTestMethodInfo.Setup(ds => ds.GetAttributes <TestFrameworkV2.DataSourceAttribute>(false))
.Returns(new TestFrameworkV2.DataSourceAttribute[] { dataSourceAttribute });
TestFrameworkV2.TestResult testResult = new TestFrameworkV2.TestResult();
DummyTestClass testClassInstance = new DummyTestClass();
var methodInfo = typeof(DummyTestClass).GetMethod("PassingTest");
this.mockTestMethodInfo.Setup(ds => ds.Invoke(null)).
Callback(() =>
{
try
{
testClassInstance.TestContext = this.testContextImplementation;
var task = methodInfo.Invoke(testClassInstance, null) as Task;
task?.GetAwaiter().GetResult();
testResult.Outcome = TestFrameworkV2.UnitTestOutcome.Passed;
}
catch (Exception ex)
{
testResult.Outcome = TestFrameworkV2.UnitTestOutcome.Failed;
testResult.TestFailureException = ex;
}
}).Returns(testResult);
this.mockTestMethodInfo.Setup(ds => ds.MethodInfo).Returns(methodInfo);
TestFrameworkV2.TestMethodAttribute testMethodAttribute = new TestFrameworkV2.TestMethodAttribute();
TestDataSource testDataSource = new TestDataSource();
TestFrameworkV2.TestResult[] result = testDataSource.RunDataDrivenTest(this.testContextImplementation, this.mockTestMethodInfo.Object, null, testMethodAttribute);
Assert.AreEqual(result[0].Outcome, TestFrameworkV2.UnitTestOutcome.Passed);
}
public void ShouldReceiveDummyImageWhenSentOne()
{
const int port = 8090;
var ipEndpoint = new IPEndPoint(IPAddress.Parse(CameraImageProvider.LocalhostIpAddress), port);
var udpSender = new UdpClient();
var imageModel = new ImageModel(1024, 768, ImageBitDepth.Bpp8);
var template = new ImageProviderTemplate
{
ImageProviderType = ImageProviderType.CameraProvider,
ImageModel = imageModel,
CameraImageProviderTemplate = new CameraImageProviderTemplate {
Port = port, Timeout = 10000
}
};
var cameraImageProvider = new ImageProviderFactory().CreateInstance(template);
Image image;
// When
Task.Run(() =>
{
var dummyImageEnumerator = TestDataSource.SimulateSendingOfDummyImage(imageModel).GetEnumerator();
while (dummyImageEnumerator.MoveNext())
{
var bytesToSend = dummyImageEnumerator.Current;
udpSender.Send(bytesToSend, bytesToSend.Length, ipEndpoint);
}
});
cameraImageProvider.TryToObtainImage(out image);
udpSender.Close();
// Then
var expectedImage = TestDataSource.GetExpectedDummyImage(imageModel);
Assert.AreEqual(expectedImage, image);
}
public void AddDuplicateImage()
{
IImageViewer viewer = new ImageViewerComponent();
StudyTree studyTree = viewer.StudyTree;
string studyUid1 = DicomUid.GenerateUid().UID;
string seriesUid1 = DicomUid.GenerateUid().UID;
string imageUid1 = DicomUid.GenerateUid().UID;
ImageSop image1 = CreateImageSop("patient1", studyUid1, seriesUid1, imageUid1);
ImageSop image2 = CreateImageSop("patient1", studyUid1, seriesUid1, imageUid1);
Assert.IsTrue(studyTree.AddSop(image1));
Assert.IsFalse(studyTree.AddSop(image2));
Assert.IsTrue(studyTree.Patients["patient1"].Studies[studyUid1].Series[seriesUid1].Sops.Count == 1);
TestDataSource dataSource = (TestDataSource)image1.DataSource;
viewer.Dispose();
Assert.IsTrue(dataSource.IsDisposed);
}
protected IQueryable RunQuery(string query, int maxResults = 0, IQueryable data = null)
{
IQueryable results = null;
ApplyQueryOption subject = null;
ODataQuerySettings settings;
EdmModel model;
ODataQueryContext context;
IAssembliesResolver assembliesResolver;
GetApplyToParams(out settings, out model, out context, out assembliesResolver);
if (maxResults != 0)
{
settings.PageSize = maxResults;
}
subject = GetApplyQueryOption(query);
if (data == null)
{
data = TestDataSource.CreateData();
}
results = subject.ApplyTo(data, settings, assembliesResolver);
return(results);
}
public void CompoundListPrepend ()
{
var source = new TestDataSource ();
IDataSource s = source;
source.DataItems.Add (new DataItem ("Foo1", "Bar1"));
source.DataItems.Add (new DataItem ("Foo2", "Bar2"));
var compoundList = new CompoundCollection {
MainList = s.Data
};
var prependItem = new DataItem ("Pre1", "Val1");
compoundList.PrependList.Add (prependItem);
Assert.AreEqual (prependItem, compoundList[0]);
Assert.AreEqual (source.DataItems[0], s.Data[0]);
Assert.AreEqual (source.DataItems[1], s.Data[1]);
Assert.AreEqual (source.DataItems[0], compoundList[1]);
Assert.AreEqual (source.DataItems[1], compoundList[2]);
s.MaskKey ("Foo1");
Assert.AreEqual (source.DataItems[1], compoundList[1]);
}
static void Main()
{
using (var db = new TestDbManager("MySql"))
{
var src = new TestDataSource(db);
var allParents = src.Parent;
var allPersons = src.Person;
var @p1 = "a";
var query = from e in allParents
join c in allPersons on e.Id equals c.Id
where c.Name.StartsWith(@p1)
orderby c.Name
select e;
Console.WriteLine(query.Expression.ToString());
Console.WriteLine();
Console.WriteLine(query);
var result = query.ToArray();
Console.WriteLine(result.Length);
}
}
static void Main()
{
using (var db = new TestDbManager("MySql"))
{
var src = new TestDataSource(db);
var allParents = src.Parent;
var allPersons = src.Person;
var @p1 = "a";
var query = from e in allParents
join c in allPersons on e.Id equals c.Id
where c.Name.StartsWith(@p1)
orderby c.Name
select e;
Console.WriteLine(query.Expression.ToString());
Console.WriteLine();
Console.WriteLine(query);
var result = query.ToArray();
Console.WriteLine(result.Length);
}
}
private void TestSeriesSplittingSingleImage_MixedMultiframeSeries(int numberOfMultiframes, int numberOfSingleframes)
{
const int numberOfSeries = 1;
int instancesPerSeries = numberOfMultiframes + numberOfSingleframes;
const int multiFrameNumberOfFrames = 5;
List <TestDataSource> dataSources = CreateMRStudyDataSources(numberOfSeries, instancesPerSeries, "1.2.3");
for (int i = 0; i < numberOfMultiframes; ++i)
{
TestDataSource multiFrameDataSource = dataSources[i];
multiFrameDataSource.File.DataSet[DicomTags.NumberOfFrames].SetInt32(0, multiFrameNumberOfFrames);
}
StudyTree studyTree = CreateStudyTree(ConvertToSops(dataSources));
BasicDisplaySetFactory factory = new BasicDisplaySetFactory {
CreateSingleImageDisplaySets = instancesPerSeries > 1
};
List <IDisplaySet> allDisplaySets = new List <IDisplaySet>();
int numberOfMultiframesFound = 0;
int numberOfSingleframesFound = 0;
try
{
Patient patient = studyTree.Patients[0];
Study study = patient.Studies[0];
Assert.AreEqual(numberOfSeries, study.Series.Count, "There should be exactly {0} series", numberOfSeries);
foreach (Series series in study.Series)
{
Assert.AreEqual(instancesPerSeries, series.Sops.Count, "There should be exactly {0} sops", instancesPerSeries);
List <IDisplaySet> displaySets = factory.CreateDisplaySets(series);
allDisplaySets.AddRange(displaySets);
foreach (IDisplaySet displaySet in displaySets)
{
ImageSop imageSop = ((IImageSopProvider)displaySet.PresentationImages[0]).ImageSop;
if (imageSop.NumberOfFrames > 1)
{
++numberOfMultiframesFound;
Assert.AreEqual(multiFrameNumberOfFrames, displaySet.PresentationImages.Count, "There should be {0} presentation image per display set", multiFrameNumberOfFrames);
if (instancesPerSeries > 1)
{
Assert.AreEqual(typeof(MultiframeDisplaySetDescriptor), displaySet.Descriptor.GetType(), "Wrong display set descriptor type");
Assert.IsTrue(displaySet.Name.Contains("Multiframe #"), "display set name doesn't contain \"Multiframe #\"");
}
}
else
{
++numberOfSingleframesFound;
Assert.AreEqual(1, displaySet.PresentationImages.Count, "There should be only one presentation image per display set");
if (instancesPerSeries > 1)
{
Assert.AreEqual(typeof(SingleImageDisplaySetDescriptor), displaySet.Descriptor.GetType(), "Wrong display set descriptor type");
Assert.IsTrue(displaySet.Name.Contains("Image #"), "display set name doesn't contain \"Image #\"");
}
}
if (instancesPerSeries == 1)
{
if (numberOfMultiframes == 1)
{
Assert.AreEqual(multiFrameNumberOfFrames, displaySet.PresentationImages.Count, "There should be one presentation image per frame");
}
else
{
Assert.AreEqual(1, displaySet.PresentationImages.Count, "There should be only one presentation image per display set");
}
Assert.AreEqual(typeof(SeriesDisplaySetDescriptor), displaySet.Descriptor.GetType(), "Wrong display set descriptor type");
}
}
}
}
finally
{
foreach (IDisplaySet displaySet in allDisplaySets)
{
displaySet.Dispose();
}
studyTree.Dispose();
}
Assert.AreEqual(numberOfMultiframes, numberOfMultiframesFound, "Incorrect number of multiframes");
Assert.AreEqual(numberOfSingleframes, numberOfSingleframesFound, "Incorrect number of singleframes");
}
private void Init()
{
Current.Reset();
var factory = Mock.Of <IFactory>();
Current.Factory = factory;
var configs = new Configs();
Mock.Get(factory).Setup(x => x.GetInstance(typeof(Configs))).Returns(configs);
var globalSettings = new GlobalSettings();
configs.Add(SettingsForTests.GenerateMockUmbracoSettings);
configs.Add <IGlobalSettings>(() => globalSettings);
var publishedModelFactory = new NoopPublishedModelFactory();
Mock.Get(factory).Setup(x => x.GetInstance(typeof(IPublishedModelFactory))).Returns(publishedModelFactory);
// create a content node kit
var kit = new ContentNodeKit
{
ContentTypeId = 2,
Node = new ContentNode(1, Guid.NewGuid(), 0, "-1,1", 0, -1, DateTime.Now, 0),
DraftData = new ContentData
{
Name = "It Works2!",
Published = false,
TemplateId = 0,
VersionId = 2,
VersionDate = DateTime.Now,
WriterId = 0,
Properties = new Dictionary <string, PropertyData[]> {
{ "prop", new[]
{
new PropertyData {
Culture = "", Segment = "", Value = "val2"
},
new PropertyData {
Culture = "fr-FR", Segment = "", Value = "val-fr2"
},
new PropertyData {
Culture = "en-UK", Segment = "", Value = "val-uk2"
},
new PropertyData {
Culture = "dk-DA", Segment = "", Value = "val-da2"
},
new PropertyData {
Culture = "de-DE", Segment = "", Value = "val-de2"
}
} }
},
CultureInfos = new Dictionary <string, CultureVariation>
{
// draft data = everything, and IsDraft indicates what's edited
{ "fr-FR", new CultureVariation {
Name = "name-fr2", IsDraft = true, Date = new DateTime(2018, 01, 03, 01, 00, 00)
} },
{ "en-UK", new CultureVariation {
Name = "name-uk2", IsDraft = true, Date = new DateTime(2018, 01, 04, 01, 00, 00)
} },
{ "dk-DA", new CultureVariation {
Name = "name-da2", IsDraft = true, Date = new DateTime(2018, 01, 05, 01, 00, 00)
} },
{ "de-DE", new CultureVariation {
Name = "name-de1", IsDraft = false, Date = new DateTime(2018, 01, 02, 01, 00, 00)
} }
}
},
PublishedData = new ContentData
{
Name = "It Works1!",
Published = true,
TemplateId = 0,
VersionId = 1,
VersionDate = DateTime.Now,
WriterId = 0,
Properties = new Dictionary <string, PropertyData[]> {
{ "prop", new[]
{
new PropertyData {
Culture = "", Segment = "", Value = "val1"
},
new PropertyData {
Culture = "fr-FR", Segment = "", Value = "val-fr1"
},
new PropertyData {
Culture = "en-UK", Segment = "", Value = "val-uk1"
}
} }
},
CultureInfos = new Dictionary <string, CultureVariation>
{
// published data = only what's actually published, and IsDraft has to be false
{ "fr-FR", new CultureVariation {
Name = "name-fr1", IsDraft = false, Date = new DateTime(2018, 01, 01, 01, 00, 00)
} },
{ "en-UK", new CultureVariation {
Name = "name-uk1", IsDraft = false, Date = new DateTime(2018, 01, 02, 01, 00, 00)
} },
{ "de-DE", new CultureVariation {
Name = "name-de1", IsDraft = false, Date = new DateTime(2018, 01, 02, 01, 00, 00)
} }
}
}
};
// create a data source for NuCache
var dataSource = new TestDataSource(kit);
var runtime = Mock.Of <IRuntimeState>();
Mock.Get(runtime).Setup(x => x.Level).Returns(RuntimeLevel.Run);
// create data types, property types and content types
var dataType = new DataType(new VoidEditor("Editor", Mock.Of <ILogger>()))
{
Id = 3
};
var dataTypes = new[]
{
dataType
};
_propertyType = new PropertyType("Umbraco.Void.Editor", ValueStorageType.Nvarchar)
{
Alias = "prop", DataTypeId = 3, Variations = ContentVariation.Culture
};
_contentType = new ContentType(-1)
{
Id = 2, Alias = "alias-ct", Variations = ContentVariation.Culture
};
_contentType.AddPropertyType(_propertyType);
var contentTypes = new[]
{
_contentType
};
var contentTypeService = new Mock <IContentTypeService>();
contentTypeService.Setup(x => x.GetAll()).Returns(contentTypes);
contentTypeService.Setup(x => x.GetAll(It.IsAny <int[]>())).Returns(contentTypes);
var mediaTypeService = new Mock <IMediaTypeService>();
mediaTypeService.Setup(x => x.GetAll()).Returns(Enumerable.Empty <IMediaType>());
mediaTypeService.Setup(x => x.GetAll(It.IsAny <int[]>())).Returns(Enumerable.Empty <IMediaType>());
var contentTypeServiceBaseFactory = new Mock <IContentTypeBaseServiceProvider>();
contentTypeServiceBaseFactory.Setup(x => x.For(It.IsAny <IContentBase>())).Returns(contentTypeService.Object);
var dataTypeService = Mock.Of <IDataTypeService>();
Mock.Get(dataTypeService).Setup(x => x.GetAll()).Returns(dataTypes);
// create a service context
var serviceContext = ServiceContext.CreatePartial(
dataTypeService: dataTypeService,
memberTypeService: Mock.Of <IMemberTypeService>(),
memberService: Mock.Of <IMemberService>(),
contentTypeService: contentTypeService.Object,
mediaTypeService: mediaTypeService.Object,
localizationService: Mock.Of <ILocalizationService>(),
domainService: Mock.Of <IDomainService>()
);
// create a scope provider
var scopeProvider = Mock.Of <IScopeProvider>();
Mock.Get(scopeProvider)
.Setup(x => x.CreateScope(
It.IsAny <IsolationLevel>(),
It.IsAny <RepositoryCacheMode>(),
It.IsAny <IEventDispatcher>(),
It.IsAny <bool?>(),
It.IsAny <bool>(),
It.IsAny <bool>()))
.Returns(Mock.Of <IScope>);
// create a published content type factory
var contentTypeFactory = new PublishedContentTypeFactory(
Mock.Of <IPublishedModelFactory>(),
new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()),
dataTypeService);
// create a variation accessor
_variationAccesor = new TestVariationContextAccessor();
// at last, create the complete NuCache snapshot service!
var options = new PublishedSnapshotServiceOptions {
IgnoreLocalDb = true
};
_snapshotService = new PublishedSnapshotService(options,
null,
runtime,
serviceContext,
contentTypeFactory,
null,
new TestPublishedSnapshotAccessor(),
_variationAccesor,
Mock.Of <IProfilingLogger>(),
scopeProvider,
Mock.Of <IDocumentRepository>(),
Mock.Of <IMediaRepository>(),
Mock.Of <IMemberRepository>(),
new TestDefaultCultureAccessor(),
dataSource,
globalSettings,
Mock.Of <IEntityXmlSerializer>(),
Mock.Of <IPublishedModelFactory>(),
new UrlSegmentProviderCollection(new[] { new DefaultUrlSegmentProvider() }));
// invariant is the current default
_variationAccesor.VariationContext = new VariationContext();
Mock.Get(factory).Setup(x => x.GetInstance(typeof(IVariationContextAccessor))).Returns(_variationAccesor);
}
public void AnchoringAtRepeaterMiddle()
{
using (ScrollPresenterTestHooksHelper scrollPresenterTestHooksHelper = new ScrollPresenterTestHooksHelper(
enableAnchorNotifications: true,
enableInteractionSourcesNotifications: true,
enableExpressionAnimationStatusNotifications: false))
{
using (PrivateLoggingHelper privateLoggingHelper = new PrivateLoggingHelper("ScrollPresenter"))
{
ScrollPresenter scrollPresenter = null;
AutoResetEvent scrollPresenterLoadedEvent = new AutoResetEvent(false);
AutoResetEvent scrollPresenterViewChangedEvent = new AutoResetEvent(false);
RunOnUIThread.Execute(() =>
{
scrollPresenter = new ScrollPresenter();
SetupRepeaterAnchoringUI(scrollPresenter, scrollPresenterLoadedEvent);
scrollPresenter.HorizontalAnchorRatio = double.NaN;
scrollPresenter.VerticalAnchorRatio = 0.5;
});
WaitForEvent("Waiting for Loaded event", scrollPresenterLoadedEvent);
ZoomTo(scrollPresenter, 2.0f, 0.0f, 0.0f, ScrollingAnimationMode.Enabled, ScrollingSnapPointsMode.Ignore);
ScrollTo(scrollPresenter, 0.0, 250.0, ScrollingAnimationMode.Enabled, ScrollingSnapPointsMode.Ignore, false /*hookViewChanged*/);
ItemsRepeater repeater = null;
TestDataSource dataSource = null;
RunOnUIThread.Execute(() =>
{
repeater = (scrollPresenter.Content as Border).Child as ItemsRepeater;
dataSource = repeater.ItemsSource as TestDataSource;
scrollPresenter.ViewChanged += delegate(ScrollPresenter sender, object args) {
scrollPresenterViewChangedEvent.Set();
};
Log.Comment("Inserting items at the beginning");
dataSource.Insert(0 /*index*/, 2 /*count*/);
});
WaitForEvent("Waiting for ScrollPresenter.ViewChanged event", scrollPresenterViewChangedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("ScrollPresenter offset change expected");
Verify.AreEqual(520.0, scrollPresenter.VerticalOffset);
});
RunOnUIThread.Execute(() =>
{
scrollPresenterViewChangedEvent.Reset();
Log.Comment("Removing items from the beginning");
dataSource.Remove(0 /*index*/, 2 /*count*/);
});
WaitForEvent("Waiting for ScrollPresenter.ViewChanged event", scrollPresenterViewChangedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("ScrollPresenter offset change expected");
Verify.AreEqual(250.0, scrollPresenter.VerticalOffset);
Log.Comment("ScrollPresenter CurrentAnchor is " + (scrollPresenter.CurrentAnchor == null ? "null" : "non-null"));
Verify.IsNotNull(scrollPresenter.CurrentAnchor);
});
}
}
}
public void AnchoringAtRepeaterMiddle()
{
using (ScrollerTestHooksHelper scrollerTestHooksHelper = new ScrollerTestHooksHelper())
{
using (PrivateLoggingHelper privateLoggingHelper = new PrivateLoggingHelper("Scroller"))
{
Scroller scroller = null;
AutoResetEvent scrollerLoadedEvent = new AutoResetEvent(false);
AutoResetEvent scrollerViewChangedEvent = new AutoResetEvent(false);
RunOnUIThread.Execute(() =>
{
scroller = new Scroller();
SetupRepeaterAnchoringUI(scroller, scrollerLoadedEvent);
scroller.HorizontalAnchorRatio = double.NaN;
scroller.VerticalAnchorRatio = 0.5;
});
WaitForEvent("Waiting for Loaded event", scrollerLoadedEvent);
ChangeZoomFactor(scroller, 2.0f, 0.0f, 0.0f, ScrollerViewKind.Absolute, ScrollerViewChangeKind.AllowAnimation);
ChangeOffsets(scroller, 0.0, 250.0, ScrollerViewKind.Absolute, ScrollerViewChangeKind.AllowAnimation, ScrollerViewChangeSnapPointRespect.IgnoreSnapPoints, false /*hookViewChanged*/);
ItemsRepeater repeater = null;
TestDataSource dataSource = null;
RunOnUIThread.Execute(() =>
{
repeater = (scroller.Child as Border).Child as ItemsRepeater;
dataSource = repeater.ItemsSource as TestDataSource;
scroller.ViewChanged += delegate(Scroller sender, object args) {
scrollerViewChangedEvent.Set();
};
Log.Comment("Inserting items at the beginning");
dataSource.Insert(0 /*index*/, 2 /*count*/);
});
WaitForEvent("Waiting for Scroller.ViewChanged event", scrollerViewChangedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("Scroller offset change expected");
Verify.AreEqual(scroller.VerticalOffset, 520.0);
});
RunOnUIThread.Execute(() =>
{
scrollerViewChangedEvent.Reset();
Log.Comment("Removing items from the beginning");
dataSource.Remove(0 /*index*/, 2 /*count*/);
});
WaitForEvent("Waiting for Scroller.ViewChanged event", scrollerViewChangedEvent);
RunOnUIThread.Execute(() =>
{
Log.Comment("Scroller offset change expected");
Verify.AreEqual(scroller.VerticalOffset, 250.0);
});
}
}
}
public void TestKeyImages(int numberOfFrames, int numberOfMultiframeKeyImages, int numberOfSingleFrameKeyImages, bool doSplitting)
{
Assert.IsTrue(numberOfFrames == 0 || numberOfFrames > 1);
Assert.IsTrue(numberOfMultiframeKeyImages <= numberOfFrames);
const int numberOfSeries = 1;
int instancesPerSeries = numberOfSingleFrameKeyImages + ((numberOfFrames > 0) ? 1 : 0);
Assert.IsTrue(instancesPerSeries > 0);
List <TestDataSource> dataSources = CreateMRStudyDataSources(numberOfSeries, instancesPerSeries, "1.2.3");
if (numberOfFrames > 0)
{
TestDataSource multiFrameDataSource = dataSources[0];
DicomAttributeCollection oldDataSet = multiFrameDataSource.File.DataSet;
DicomAttributeCollection newDataSet = new DicomAttributeCollection();
DicomFile newFile = new DicomFile("", new DicomAttributeCollection(), newDataSet);
//Yes this is the world's crappiest hack.
base.SetupMultiframeXA(newDataSet, 512, 512, (uint)numberOfFrames);
//because of an exception that gets thrown from the DateTimeParser
newDataSet[DicomTags.StudyDate].SetNullValue();
newDataSet[DicomTags.StudyTime].SetNullValue();
newDataSet[DicomTags.SeriesDate].SetNullValue();
newDataSet[DicomTags.SeriesTime].SetNullValue();
newDataSet[DicomTags.ReferencedStudySequence].SetEmptyValue();
newDataSet[DicomTags.Modality].SetStringValue("MR");
newDataSet[DicomTags.StudyInstanceUid].SetStringValue(oldDataSet[DicomTags.StudyInstanceUid].ToString());
newDataSet[DicomTags.SeriesInstanceUid].SetStringValue(oldDataSet[DicomTags.SeriesInstanceUid].ToString());
dataSources[0] = new TestDataSource(newFile);
}
StudyTree studyTree = CreateStudyTree(ConvertToSops(dataSources));
KeyImageSerializer serializer = new KeyImageSerializer();
Patient patient = studyTree.Patients[0];
Study study = patient.Studies[0];
Series sourceSeries = study.Series[0];
List <IDisplaySet> allDisplaySets = new List <IDisplaySet>();
BasicDisplaySetFactory factory = new BasicDisplaySetFactory();
factory.SetStudyTree(studyTree);
List <IDisplaySet> displaySets = factory.CreateDisplaySets(sourceSeries);
allDisplaySets.AddRange(displaySets);
List <DicomFile> presentationStates = new List <DicomFile>();
int numberOfMultiframeKeyImagesCreated = 0;
foreach (IDisplaySet displaySet in displaySets)
{
foreach (IPresentationImage image in displaySet.PresentationImages)
{
Frame frame = ((IImageSopProvider)image).Frame;
if (frame.ParentImageSop.NumberOfFrames > 1)
{
if (numberOfMultiframeKeyImagesCreated >= numberOfMultiframeKeyImages)
{
continue;
}
++numberOfMultiframeKeyImagesCreated;
}
DicomSoftcopyPresentationState presentationState = DicomSoftcopyPresentationState.Create(image);
//because of an exception that gets thrown from the DateTimeParser
presentationState.DicomFile.DataSet[DicomTags.StudyDate].SetNullValue();
presentationState.DicomFile.DataSet[DicomTags.StudyTime].SetNullValue();
presentationState.DicomFile.DataSet[DicomTags.SeriesDate].SetNullValue();
presentationState.DicomFile.DataSet[DicomTags.SeriesTime].SetNullValue();
presentationStates.Add(presentationState.DicomFile);
serializer.AddImage(frame, presentationState);
}
}
List <DicomFile> files = serializer.Serialize();
List <TestDataSource> keyImageDataSources = ConvertToDataSources(files);
List <Sop> keyImageSops = ConvertToSops(keyImageDataSources);
keyImageSops.AddRange(ConvertToSops(ConvertToDataSources(presentationStates)));
foreach (Sop sop in keyImageSops)
{
studyTree.AddSop(sop);
}
try
{
foreach (Series series in study.Series)
{
if (series.Modality != "KO")
{
continue;
}
List <IDisplaySet> keyImageDisplaySets;
if (doSplitting)
{
factory.CreateSingleImageDisplaySets = true;
keyImageDisplaySets = factory.CreateDisplaySets(series);
if (keyImageDisplaySets.Count == 0)
{
factory.CreateSingleImageDisplaySets = false;
keyImageDisplaySets = factory.CreateDisplaySets(series);
}
}
else
{
keyImageDisplaySets = factory.CreateDisplaySets(series);
}
allDisplaySets.AddRange(keyImageDisplaySets);
int numberOfKeyImages = numberOfMultiframeKeyImages + numberOfSingleFrameKeyImages;
if (!doSplitting)
{
Assert.AreEqual(1, keyImageDisplaySets.Count, "There should be only one display set");
IDisplaySet keyImageDisplaySet = keyImageDisplaySets[0];
Assert.AreEqual(numberOfKeyImages, keyImageDisplaySet.PresentationImages.Count, "Expected {0} images", numberOfKeyImages);
Assert.AreEqual(typeof(KOSelectionDocumentDisplaySetDescriptor), keyImageDisplaySet.Descriptor.GetType(), "Wrong display set descriptor type");
}
else
{
Assert.AreEqual(numberOfKeyImages, keyImageDisplaySets.Count, "Expected {0} display sets", numberOfKeyImages);
foreach (IDisplaySet keyImageDisplaySet in keyImageDisplaySets)
{
Assert.AreEqual(1, keyImageDisplaySet.PresentationImages.Count, "There should be only one presentation image");
IPresentationImage keyImage = keyImageDisplaySet.PresentationImages[0];
ImageSop sop = ((IImageSopProvider)keyImage).ImageSop;
Assert.AreEqual(sourceSeries.SeriesInstanceUid, sop.SeriesInstanceUid, "Series Instance Uid is not that of the source series");
if (numberOfKeyImages == 1)
{
Assert.AreEqual(typeof(KOSelectionDocumentDisplaySetDescriptor), keyImageDisplaySet.Descriptor.GetType(), "Wrong display set descriptor type");
}
else if (sop.NumberOfFrames > 1)
{
Assert.AreEqual(typeof(KOSelectionSingleFrameDisplaySetDescriptor), keyImageDisplaySet.Descriptor.GetType(), "Wrong display set descriptor type");
}
else
{
Assert.AreEqual(typeof(KOSelectionSingleImageDisplaySetDescriptor), keyImageDisplaySet.Descriptor.GetType(), "Wrong display set descriptor type");
}
}
}
}
}
finally
{
foreach (IDisplaySet displaySet in allDisplaySets)
{
displaySet.Dispose();
}
studyTree.Dispose();
}
}
public void StandaloneVariations()
{
// this test implements a full standalone NuCache (based upon a test IDataSource, does not
// use any local db files, does not rely on any database) - and tests variations
Current.Reset();
Current.UnlockConfigs();
Current.Configs.Add(SettingsForTests.GenerateMockUmbracoSettings);
Current.Configs.Add <IGlobalSettings>(() => new GlobalSettings());
var globalSettings = Current.Configs.Global();
// create a content node kit
var kit = new ContentNodeKit
{
ContentTypeId = 2,
Node = new ContentNode(1, Guid.NewGuid(), 0, "-1,1", 0, -1, DateTime.Now, 0),
DraftData = new ContentData {
Name = "It Works2!", Published = false, TemplateId = 0, VersionId = 2, VersionDate = DateTime.Now, WriterId = 0,
Properties = new Dictionary <string, PropertyData[]> {
{ "prop", new[]
{
new PropertyData {
Culture = "", Segment = "", Value = "val2"
},
new PropertyData {
Culture = "fr-FR", Segment = "", Value = "val-fr2"
},
new PropertyData {
Culture = "en-UK", Segment = "", Value = "val-uk2"
}
} }
},
CultureInfos = new Dictionary <string, CultureVariation>
{
{ "fr-FR", new CultureVariation {
Name = "name-fr2", Date = new DateTime(2018, 01, 03, 01, 00, 00)
} },
{ "en-UK", new CultureVariation {
Name = "name-uk2", Date = new DateTime(2018, 01, 04, 01, 00, 00)
} }
}
},
PublishedData = new ContentData {
Name = "It Works1!", Published = true, TemplateId = 0, VersionId = 1, VersionDate = DateTime.Now, WriterId = 0,
Properties = new Dictionary <string, PropertyData[]> {
{ "prop", new[]
{
new PropertyData {
Culture = "", Segment = "", Value = "val1"
},
new PropertyData {
Culture = "fr-FR", Segment = "", Value = "val-fr1"
},
new PropertyData {
Culture = "en-UK", Segment = "", Value = "val-uk1"
}
} }
},
CultureInfos = new Dictionary <string, CultureVariation>
{
{ "fr-FR", new CultureVariation {
Name = "name-fr1", Date = new DateTime(2018, 01, 01, 01, 00, 00)
} },
{ "en-UK", new CultureVariation {
Name = "name-uk1", Date = new DateTime(2018, 01, 02, 01, 00, 00)
} }
}
}
};
// create a data source for NuCache
var dataSource = new TestDataSource(kit);
var runtime = Mock.Of <IRuntimeState>();
Mock.Get(runtime).Setup(x => x.Level).Returns(RuntimeLevel.Run);
// create data types, property types and content types
var dataType = new DataType(new VoidEditor("Editor", Mock.Of <ILogger>()))
{
Id = 3
};
var dataTypes = new[]
{
dataType
};
var propertyType = new PropertyType("Umbraco.Void.Editor", ValueStorageType.Nvarchar)
{
Alias = "prop", DataTypeId = 3, Variations = ContentVariation.Culture
};
var contentType = new ContentType(-1)
{
Id = 2, Alias = "alias-ct", Variations = ContentVariation.Culture
};
contentType.AddPropertyType(propertyType);
var contentTypes = new[]
{
contentType
};
var contentTypeService = Mock.Of <IContentTypeService>();
Mock.Get(contentTypeService).Setup(x => x.GetAll()).Returns(contentTypes);
Mock.Get(contentTypeService).Setup(x => x.GetAll(It.IsAny <int[]>())).Returns(contentTypes);
var dataTypeService = Mock.Of <IDataTypeService>();
Mock.Get(dataTypeService).Setup(x => x.GetAll()).Returns(dataTypes);
// create a service context
var serviceContext = ServiceContext.CreatePartial(
dataTypeService: dataTypeService,
memberTypeService: Mock.Of <IMemberTypeService>(),
memberService: Mock.Of <IMemberService>(),
contentTypeService: contentTypeService,
localizationService: Mock.Of <ILocalizationService>()
);
// create a scope provider
var scopeProvider = Mock.Of <IScopeProvider>();
Mock.Get(scopeProvider)
.Setup(x => x.CreateScope(
It.IsAny <IsolationLevel>(),
It.IsAny <RepositoryCacheMode>(),
It.IsAny <IEventDispatcher>(),
It.IsAny <bool?>(),
It.IsAny <bool>(),
It.IsAny <bool>()))
.Returns(Mock.Of <IScope>);
// create a published content type factory
var contentTypeFactory = new PublishedContentTypeFactory(
Mock.Of <IPublishedModelFactory>(),
new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()),
dataTypeService);
// create a variation accessor
var variationAccessor = new TestVariationContextAccessor();
// at last, create the complete NuCache snapshot service!
var options = new PublishedSnapshotService.Options {
IgnoreLocalDb = true
};
var snapshotService = new PublishedSnapshotService(options,
null,
runtime,
serviceContext,
contentTypeFactory,
null,
new TestPublishedSnapshotAccessor(),
variationAccessor,
Mock.Of <ILogger>(),
scopeProvider,
Mock.Of <IDocumentRepository>(),
Mock.Of <IMediaRepository>(),
Mock.Of <IMemberRepository>(),
new TestDefaultCultureAccessor(),
dataSource,
globalSettings,
new SiteDomainHelper());
// get a snapshot, get a published content
var snapshot = snapshotService.CreatePublishedSnapshot(previewToken: null);
var publishedContent = snapshot.Content.GetById(1);
// invariant is the current default
variationAccessor.VariationContext = new VariationContext();
Assert.IsNotNull(publishedContent);
Assert.AreEqual("It Works1!", publishedContent.Name);
Assert.AreEqual("val1", publishedContent.Value <string>("prop"));
Assert.AreEqual("val-fr1", publishedContent.Value <string>("prop", "fr-FR"));
Assert.AreEqual("val-uk1", publishedContent.Value <string>("prop", "en-UK"));
Assert.AreEqual("name-fr1", publishedContent.GetCulture("fr-FR").Name);
Assert.AreEqual("name-uk1", publishedContent.GetCulture("en-UK").Name);
var draftContent = snapshot.Content.GetById(true, 1);
Assert.AreEqual("It Works2!", draftContent.Name);
Assert.AreEqual("val2", draftContent.Value <string>("prop"));
Assert.AreEqual("val-fr2", draftContent.Value <string>("prop", "fr-FR"));
Assert.AreEqual("val-uk2", draftContent.Value <string>("prop", "en-UK"));
Assert.AreEqual("name-fr2", draftContent.GetCulture("fr-FR").Name);
Assert.AreEqual("name-uk2", draftContent.GetCulture("en-UK").Name);
// now french is default
variationAccessor.VariationContext = new VariationContext("fr-FR");
Assert.AreEqual("val-fr1", publishedContent.Value <string>("prop"));
Assert.AreEqual("name-fr1", publishedContent.GetCulture().Name);
Assert.AreEqual("name-fr1", publishedContent.Name);
Assert.AreEqual(new DateTime(2018, 01, 01, 01, 00, 00), publishedContent.GetCulture().Date);
// now uk is default
variationAccessor.VariationContext = new VariationContext("en-UK");
Assert.AreEqual("val-uk1", publishedContent.Value <string>("prop"));
Assert.AreEqual("name-uk1", publishedContent.GetCulture().Name);
Assert.AreEqual("name-uk1", publishedContent.Name);
Assert.AreEqual(new DateTime(2018, 01, 02, 01, 00, 00), publishedContent.GetCulture().Date);
// invariant needs to be retrieved explicitely, when it's not default
Assert.AreEqual("val1", publishedContent.Value <string>("prop", culture: ""));
// but,
// if the content type / property type does not vary, then it's all invariant again
// modify the content type and property type, notify the snapshot service
contentType.Variations = ContentVariation.Nothing;
propertyType.Variations = ContentVariation.Nothing;
snapshotService.Notify(new[] { new ContentTypeCacheRefresher.JsonPayload("IContentType", publishedContent.ContentType.Id, ContentTypeChangeTypes.RefreshMain) });
// get a new snapshot (nothing changed in the old one), get the published content again
var anotherSnapshot = snapshotService.CreatePublishedSnapshot(previewToken: null);
var againContent = anotherSnapshot.Content.GetById(1);
Assert.AreEqual(ContentVariation.Nothing, againContent.ContentType.Variations);
Assert.AreEqual(ContentVariation.Nothing, againContent.ContentType.GetPropertyType("prop").Variations);
// now, "no culture" means "invariant"
Assert.AreEqual("It Works1!", againContent.Name);
Assert.AreEqual("val1", againContent.Value <string>("prop"));
}
public void Setup()
{
source = new TestDataSource();
comicList = new ComicList(source);
}
/// <summary>
/// Initializes a test.
/// </summary>
private void InitGrid()
{
dataSource = new TestDataSource(test);
grid.DataSource = dataSource;
}
private void SetupRepeaterAnchoringUI(
Scroller scroller,
AutoResetEvent scrollerLoadedEvent)
{
Log.Comment("Setting up ItemsRepeater anchoring UI with Scroller and ItemsRepeater");
TestDataSource dataSource = new TestDataSource(
Enumerable.Range(0, c_defaultAnchoringUIRepeaterChildrenCount).Select(i => string.Format("Item #{0}", i)).ToList());
RecyclingElementFactory elementFactory = new RecyclingElementFactory();
elementFactory.RecyclePool = new RecyclePool();
elementFactory.Templates["Item"] = XamlReader.Load(
@"<DataTemplate xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation'>
<Border BorderThickness='3' BorderBrush='Chartreuse' Width='100' Height='100' Margin='3' Background='BlanchedAlmond'>
<TextBlock Text='{Binding}' HorizontalAlignment='Center' VerticalAlignment='Center'/>
</Border>
</DataTemplate>") as DataTemplate;
ItemsRepeater repeater = new ItemsRepeater()
{
Name = "repeater",
ItemsSource = dataSource,
#if BUILD_WINDOWS
ItemTemplate = (Windows.UI.Xaml.IElementFactory)elementFactory,
#else
ItemTemplate = elementFactory,
#endif
Layout = new UniformGridLayout()
{
MinItemWidth = 125,
MinItemHeight = 125,
MinRowSpacing = 10,
MinColumnSpacing = 10
},
Margin = new Thickness(30)
};
Border border = new Border()
{
Name = "border",
BorderThickness = new Thickness(3),
BorderBrush = new SolidColorBrush(Colors.Chartreuse),
Margin = new Thickness(15),
Background = new SolidColorBrush(Colors.Beige),
Child = repeater
};
Verify.IsNotNull(scroller);
scroller.Name = "scroller";
scroller.IsChildAvailableWidthConstrained = true;
scroller.Width = 400;
scroller.Height = 600;
scroller.Background = new SolidColorBrush(Colors.AliceBlue);
scroller.Child = border;
if (scrollerLoadedEvent != null)
{
scroller.Loaded += (object sender, RoutedEventArgs e) =>
{
Log.Comment("Scroller.Loaded event handler");
scrollerLoadedEvent.Set();
};
}
scroller.AnchorRequested += (Scroller sender, ScrollerAnchorRequestedEventArgs args) =>
{
Log.Comment("Scroller.AnchorRequested event handler");
Verify.IsNull(args.AnchorElement);
Verify.IsGreaterThan(args.AnchorCandidates.Count, 0);
};
Log.Comment("Setting window content");
MUXControlsTestApp.App.TestContentRoot = scroller;
}
public void TestEnhancedAgentCodeSequence()
{
var agent1 = new CodeSequenceMacro {
CodeMeaning = "Contrastinol", CodeValue = "123", CodingSchemeDesignator = "ABC"
};
var agent2 = new CodeSequenceMacro {
CodeMeaning = "Bolusinate", CodeValue = "456", CodingSchemeDesignator = "DEF"
};
var agent3 = new CodeSequenceMacro {
CodeMeaning = "Dilithium", CodeValue = "789", CodingSchemeDesignator = "GHI"
};
var usageFrame1 = new ContrastBolusUsageFunctionalGroup
{
ContrastBolusUsageSequence = new[]
{
new ContrastBolusUsageSequenceItem {
ContrastBolusAgentNumber = 1
},
new ContrastBolusUsageSequenceItem {
ContrastBolusAgentNumber = 3
}
}
};
var usageFrame2 = new ContrastBolusUsageFunctionalGroup
{
ContrastBolusUsageSequence = new[]
{
new ContrastBolusUsageSequenceItem {
ContrastBolusAgentNumber = 2
}
}
};
var usageFrame3 = new ContrastBolusUsageFunctionalGroup(new DicomSequenceItem())
{
ContrastBolusUsageSequence = new[]
{
new ContrastBolusUsageSequenceItem {
ContrastBolusAgentNumber = 999
},
new ContrastBolusUsageSequenceItem {
ContrastBolusAgentNumber = 2
}
}
};
var usageFrame4 = new ContrastBolusUsageFunctionalGroup(new DicomSequenceItem());
var dataset = TestDataSource.CreateImageSopDataSource(4);
dataset[DicomTags.ContrastBolusAgent].SetStringValue(@"Contrastinol and Bolusinate");
dataset[DicomTags.ContrastBolusAgentSequence].AddSequenceItem(agent1.DicomSequenceItem);
dataset[DicomTags.ContrastBolusAgentSequence].AddSequenceItem(agent2.DicomSequenceItem);
dataset[DicomTags.ContrastBolusAgentSequence].AddSequenceItem(agent3.DicomSequenceItem);
dataset[DicomTags.PerFrameFunctionalGroupsSequence].AddSequenceItem(usageFrame1.DicomSequenceItem);
dataset[DicomTags.PerFrameFunctionalGroupsSequence].AddSequenceItem(usageFrame2.DicomSequenceItem);
dataset[DicomTags.PerFrameFunctionalGroupsSequence].AddSequenceItem(usageFrame3.DicomSequenceItem);
dataset[DicomTags.PerFrameFunctionalGroupsSequence].AddSequenceItem(usageFrame4.DicomSequenceItem);
agent1.DicomSequenceItem[DicomTags.ContrastBolusAgentNumber].SetInt32(0, 1);
agent2.DicomSequenceItem[DicomTags.ContrastBolusAgentNumber].SetInt32(0, 2);
agent3.DicomSequenceItem[DicomTags.ContrastBolusAgentNumber].SetInt32(0, 3);
using (var sop = (ImageSop)Sop.Create(dataset))
using (var images = new DisposableList <IPresentationImage>(PresentationImageFactory.Create(sop)))
{
Assert.AreEqual(@"Contrastinol\Dilithium", _annotationItems[_cbAgent].GetAnnotationText(images[0]), "Frame 1");
Assert.AreEqual(@"Bolusinate", _annotationItems[_cbAgent].GetAnnotationText(images[1]), "Frame 2");
Assert.AreEqual(@"Bolusinate", _annotationItems[_cbAgent].GetAnnotationText(images[2]), "Frame 3");
Assert.IsEmpty(_annotationItems[_cbAgent].GetAnnotationText(images[3]), "Frame 4");
agent1.CodeMeaning = string.Empty;
agent2.CodeMeaning = string.Empty;
Assert.AreEqual(@"123 (ABC)\Dilithium", _annotationItems[_cbAgent].GetAnnotationText(images[0]), "Frame 1");
Assert.AreEqual(@"456 (DEF)", _annotationItems[_cbAgent].GetAnnotationText(images[1]), "Frame 2");
Assert.AreEqual(@"456 (DEF)", _annotationItems[_cbAgent].GetAnnotationText(images[2]), "Frame 3");
Assert.IsEmpty(_annotationItems[_cbAgent].GetAnnotationText(images[3]), "Frame 4");
agent3.CodeMeaning = string.Empty;
Assert.AreEqual(@"123 (ABC)\789 (GHI)", _annotationItems[_cbAgent].GetAnnotationText(images[0]));
Assert.AreEqual(@"456 (DEF)", _annotationItems[_cbAgent].GetAnnotationText(images[1]), "Frame 2");
Assert.AreEqual(@"456 (DEF)", _annotationItems[_cbAgent].GetAnnotationText(images[2]), "Frame 3");
Assert.IsEmpty(_annotationItems[_cbAgent].GetAnnotationText(images[3]), "Frame 4");
}
}
