import { sopClassDictionary } from './sopClassDictionary';
import { isImage } from './isImage';

describe('isImage', () => {
  test('should return true when the image is of type sopClassDictionary.ComputedRadiographyImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.ComputedRadiographyImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.DigitalXRayImageStorageForPresentation', () => {
    const isImageStatus = isImage(sopClassDictionary.DigitalXRayImageStorageForPresentation);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.DigitalXRayImageStorageForProcessing', () => {
    const isImageStatus = isImage(sopClassDictionary.DigitalXRayImageStorageForProcessing);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.DigitalMammographyXRayImageStorageForPresentation', () => {
    const isImageStatus = isImage(
      sopClassDictionary.DigitalMammographyXRayImageStorageForPresentation
    );
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.DigitalMammographyXRayImageStorageForProcessing', () => {
    const isImageStatus = isImage(
      sopClassDictionary.DigitalMammographyXRayImageStorageForProcessing
    );
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.DigitalIntraOralXRayImageStorageForPresentation', () => {
    const isImageStatus = isImage(
      sopClassDictionary.DigitalIntraOralXRayImageStorageForPresentation
    );
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.DigitalIntraOralXRayImageStorageForProcessing', () => {
    const isImageStatus = isImage(sopClassDictionary.DigitalIntraOralXRayImageStorageForProcessing);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.CTImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.CTImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.EnhancedCTImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.EnhancedCTImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.LegacyConvertedEnhancedCTImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.LegacyConvertedEnhancedCTImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.UltrasoundMultiframeImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.UltrasoundMultiframeImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.MRImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.MRImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.EnhancedMRImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.EnhancedMRImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.EnhancedMRColorImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.EnhancedMRColorImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.LegacyConvertedEnhancedMRImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.LegacyConvertedEnhancedMRImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.UltrasoundImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.UltrasoundImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.SecondaryCaptureImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.SecondaryCaptureImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.MultiframeSingleBitSecondaryCaptureImageStorage', () => {
    const isImageStatus = isImage(
      sopClassDictionary.MultiframeSingleBitSecondaryCaptureImageStorage
    );
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.MultiframeGrayscaleByteSecondaryCaptureImageStorage', () => {
    const isImageStatus = isImage(
      sopClassDictionary.MultiframeGrayscaleByteSecondaryCaptureImageStorage
    );
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.MultiframeGrayscaleWordSecondaryCaptureImageStorage', () => {
    const isImageStatus = isImage(
      sopClassDictionary.MultiframeGrayscaleWordSecondaryCaptureImageStorage
    );
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.MultiframeTrueColorSecondaryCaptureImageStorage', () => {
    const isImageStatus = isImage(
      sopClassDictionary.MultiframeTrueColorSecondaryCaptureImageStorage
    );
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.XRayAngiographicImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.XRayAngiographicImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.EnhancedXAImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.EnhancedXAImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.XRayRadiofluoroscopicImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.XRayRadiofluoroscopicImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.EnhancedXRFImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.EnhancedXRFImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.XRay3DAngiographicImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.XRay3DAngiographicImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.XRay3DCraniofacialImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.XRay3DCraniofacialImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.BreastTomosynthesisImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.BreastTomosynthesisImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.BreastProjectionXRayImageStorageForPresentation', () => {
    const isImageStatus = isImage(
      sopClassDictionary.BreastProjectionXRayImageStorageForPresentation
    );
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.BreastProjectionXRayImageStorageForProcessing', () => {
    const isImageStatus = isImage(sopClassDictionary.BreastProjectionXRayImageStorageForProcessing);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.IntravascularOpticalCoherenceTomographyImageStorageForPresentation', () => {
    const isImageStatus = isImage(
      sopClassDictionary.IntravascularOpticalCoherenceTomographyImageStorageForPresentation
    );
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.IntravascularOpticalCoherenceTomographyImageStorageForProcessing', () => {
    const isImageStatus = isImage(
      sopClassDictionary.IntravascularOpticalCoherenceTomographyImageStorageForProcessing
    );
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.NuclearMedicineImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.NuclearMedicineImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.VLEndoscopicImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.VLEndoscopicImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.VideoEndoscopicImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.VideoEndoscopicImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.VLMicroscopicImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.VLMicroscopicImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.VideoMicroscopicImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.VideoMicroscopicImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.VLSlideCoordinatesMicroscopicImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.VLSlideCoordinatesMicroscopicImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.VLPhotographicImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.VLPhotographicImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.VideoPhotographicImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.VideoPhotographicImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.OphthalmicPhotography8BitImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.OphthalmicPhotography8BitImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.OphthalmicPhotography16BitImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.OphthalmicPhotography16BitImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.OphthalmicTomographyImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.OphthalmicTomographyImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.VLWholeSlideMicroscopyImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.VLWholeSlideMicroscopyImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.PositronEmissionTomographyImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.PositronEmissionTomographyImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.EnhancedPETImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.EnhancedPETImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.LegacyConvertedEnhancedPETImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.LegacyConvertedEnhancedPETImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return true when the image is of type sopClassDictionary.RTImageStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.RTImageStorage);
    expect(isImageStatus).toBe(true);
  });

  test('should return false when the image is of type sopClassDictionary.SpatialFiducialsStorage', () => {
    const isImageStatus = isImage(sopClassDictionary.SpatialFiducialsStorage);
    expect(isImageStatus).toBe(false);
  });

  test('should return false when the image is undefined', () => {
    const isImageStatus = isImage(undefined);
    expect(isImageStatus).toBe(false);
  });

  test('should return false when the image is null', () => {
    const isImageStatus = isImage(null);
    expect(isImageStatus).toBe(false);
  });
});