public void JsonSerialization_SerializeBinaryTrue_ContainsTags()
        {
            DicomDataset ds = TranslationTestHelpers.BuildVrDataset();

            DicomTypeTranslater.SerializeBinaryData = true;
            VerifyJsonTripleTrip(ds);
        }
        public void WithSpanishTranslation_Should_AddTranslation()
        {
            var settings = new ValidatorSettings();

            settings.WithSpanishTranslation();
            TranslationTestHelpers.ShouldContainSingleTranslation(settings.Translations, "Spanish", Translation.Spanish);
        }
        public void BsonRoundTrip_NormalDataset_SameAfterConversion()
        {
            var ds = new DicomDataset(TranslationTestHelpers.BuildZooDataset()
                                      .Where(x => !DicomTypeTranslater.DicomVrBlacklist.Contains(x.ValueRepresentation)));

            VerifyBsonTripleTrip(ds);
        }
Пример #4
0
        public void WithRussianTranslation_Should_AddTranslation()
        {
            var settings = new ValidatorSettings();

            settings.WithRussianTranslation();
            TranslationTestHelpers.ShouldContainSingleTranslation(settings.Translations, "Russian", Translation.Russian);
        }
Пример #5
0
        public void WithPortugueseTranslation_Should_AddTranslation()
        {
            var settings = new ValidatorSettings();

            settings.WithPortugueseTranslation();
            TranslationTestHelpers.ShouldContainSingleTranslation(settings.Translations, "Portuguese", Translation.Portuguese);
        }
        public void TestBasicCSharpTranslation()
        {
            DicomDataset ds = TranslationTestHelpers.BuildVrDataset();

            foreach (DicomItem item in ds)
            {
                Assert.NotNull(DicomTypeTranslaterReader.GetCSharpValue(ds, item));
            }
        }
        public void Deserialize_PrivateCreators_AreSet()
        {
            DicomDataset originalDataset = TranslationTestHelpers.BuildPrivateDataset();

            ValidatePrivateCreatorsExist(originalDataset);

            string json   = JsonConvert.SerializeObject(originalDataset, new JsonDicomConverter());
            var    recoDs = JsonConvert.DeserializeObject <DicomDataset>(json, new JsonDicomConverter());

            ValidatePrivateCreatorsExist(recoDs);
        }
        public void DicomToBson_EmptyPrivateElements_StoredAsBsonNull()
        {
            DicomDataset ds  = TranslationTestHelpers.BuildAllTypesNullDataset();
            BsonDocument doc = DicomTypeTranslaterReader.BuildBsonDocument(ds);

            Assert.AreEqual(ds.Count(), doc.Count());

            foreach (BsonElement element in doc)
            {
                BsonDocument asBsonDoc = element.Value.AsBsonDocument;
                Assert.NotNull(asBsonDoc);

                Assert.True(asBsonDoc.GetValue("val").IsBsonNull); // Private elements
            }
        }
        public void BsonRoundTrip_BlacklistPrivateDataset_ZeroAfterConversion()
        {
            DicomDataset ds = TranslationTestHelpers.BuildPrivateDataset();

            ds = new DicomDataset(ds.Where(x => DicomTypeTranslater.DicomVrBlacklist.Contains(x.ValueRepresentation)));
            BsonDocument doc         = DicomTypeTranslaterReader.BuildBsonDocument(ds);
            DicomDataset recoDataset = DicomTypeTranslaterWriter.BuildDicomDataset(doc);
            BsonDocument recoDoc     = DicomTypeTranslaterReader.BuildBsonDocument(recoDataset);

            Assert.AreEqual(doc, recoDoc);

            foreach (DicomElement element in recoDataset.Select(x => (DicomElement)x))
            {
                Assert.Zero(element.Buffer.Size);
            }
        }
        public JsonDicomConverterTests(ConverterTestCase converterTestCase)
        {
            Type converterType;

            switch (converterTestCase)
            {
            case ConverterTestCase.Standard:
                converterType = typeof(JsonDicomConverter);
                break;

            case ConverterTestCase.SmiStrict:
                converterType = typeof(SmiStrictJsonDicomConverter);
                break;

            case ConverterTestCase.SmiLazy:
                converterType = typeof(SmiLazyJsonDicomConverter);
                break;

            default:
                throw new Exception("No converter for test case " + converterTestCase);
            }

            _jsonDicomConverter = TranslationTestHelpers.GetConverter(converterType);
        }
        public void TestNullDataset()
        {
            DicomDataset ds = TranslationTestHelpers.BuildAllTypesNullDataset();

            VerifyJsonTripleTrip(ds);
        }
        public void TestZooDataset()
        {
            DicomDataset ds = TranslationTestHelpers.BuildZooDataset();

            VerifyJsonTripleTrip(ds);
        }
 public void TestJsonConversionAllVrs()
 {
     VerifyJsonTripleTrip(TranslationTestHelpers.BuildVrDataset());
 }
        public void BsonRoundTrip_EmptyPrivateElements_ConvertedCorrectly()
        {
            DicomDataset ds = TranslationTestHelpers.BuildAllTypesNullDataset();

            VerifyBsonTripleTrip(ds);
        }
        public void DicomToBson_TranslatePrivateDataset_DoesNotThrow()
        {
            DicomDataset ds = TranslationTestHelpers.BuildPrivateDataset();

            Assert.DoesNotThrow(() => DicomTypeTranslaterReader.BuildBsonDocument(ds));
        }