From 57ef867d2b49e757ca299d9312c5c25af621dde4 Mon Sep 17 00:00:00 2001
From: Jan Loewe <jan.loewe@ptb.de>
Date: Tue, 20 Jun 2023 12:16:04 +0000
Subject: [PATCH] Migrate to vitest

---
 .gitlab-ci.yml                                |   9 +-
 auto-imports.d.ts                             |  20 ++
 jest.config.ts                                |  18 --
 package.json                                  |  28 ++-
 ...strativeData.CalibrationLaboratory.test.ts |  79 +++++++
 .../AdministrativeData.CoreDataType.test.ts   | 119 ++++++++++
 tests/DCC/AdministrativeData.Customer.test.ts |  76 +++++++
 tests/DCC/AdministrativeData.Items.test.ts    |   5 +-
 .../AdministrativeData.RespPersons.test.ts    |  55 +++++
 ...dministrativeData.SoftwareListType.test.ts |   5 +-
 .../DCC/AdministrativeData.Statements.test.ts | 212 ++++++++++++++++++
 tests/DCC/AdministrativeData.test.ts          |   3 +-
 .../DigitalCalibrationCertificateType.test.ts |   5 +-
 ...strativeData.CalibrationLaboratory.test.ts |   5 +-
 .../AdministrativeData.CoreDataType.test.ts   |   5 +-
 .../AdministrativeData.Customer.test.ts       |   5 +-
 .../AdministrativeData.Items.test.ts          |   5 +-
 .../AdministrativeData.RespPersons.test.ts    |   5 +-
 ...dministrativeData.SoftwareListType.test.ts |   5 +-
 .../AdministrativeData.Statements.test.ts     |   5 +-
 .../DigitalCalibrationCertificateType.test.ts |   5 +-
 ...surementResult.InfluenceConditions.test.ts |   5 +-
 ...surementResult.MeasuringEquipments.test.ts |   5 +-
 ...mentResults.MeasurementResult.Name.test.ts |   5 +-
 ...tResults.MeasurementResult.Results.test.ts |   5 +-
 ...ults.MeasurementResult.UsedMethods.test.ts |   5 +-
 .../AdministrativeData.Items_variant.test.ts  |   5 +-
 ...inistrativeData.Statements_variant.test.ts |   5 +-
 ...strativeData.CalibrationLaboratory.test.ts |   5 +-
 .../AdministrativeData.CoreDataType.test.ts   |   5 +-
 .../AdministrativeData.Customer.test.ts       |   5 +-
 .../AdministrativeData.Items.test.ts          |   5 +-
 .../AdministrativeData.RespPersons.test.ts    |   5 +-
 ...dministrativeData.SoftwareListType.test.ts |   5 +-
 .../AdministrativeData.Statements.test.ts     |   5 +-
 .../DigitalCalibrationCertificateType.test.ts |   5 +-
 ...surementResult.InfluenceConditions.test.ts |   5 +-
 ...surementResult.MeasuringEquipments.test.ts |   5 +-
 ...mentResults.MeasurementResult.Name.test.ts |   5 +-
 ...tResults.MeasurementResult.Results.test.ts |   5 +-
 ...ults.MeasurementResult.UsedMethods.test.ts |   5 +-
 ...strativeData.CalibrationLaboratory.test.ts |   5 +-
 .../AdministrativeData.CoreDataType.test.ts   |   5 +-
 .../AdministrativeData.Customer.test.ts       |   5 +-
 .../AdministrativeData.Items.test.ts          |   5 +-
 ...ministrativeData.RefTypeDefinitons.test.ts |   5 +-
 .../AdministrativeData.RespPersons.test.ts    |   5 +-
 ...dministrativeData.SoftwareListType.test.ts |   5 +-
 .../AdministrativeData.Statements.test.ts     |   5 +-
 .../DigitalCalibrationCertificateType.test.ts |   5 +-
 ...surementResult.InfluenceConditions.test.ts |   5 +-
 ...surementResult.MeasuringEquipments.test.ts |   5 +-
 ...mentResults.MeasurementResult.Name.test.ts |   5 +-
 ...tResults.MeasurementResult.Results.test.ts |   5 +-
 ...ults.MeasurementResult.UsedMethods.test.ts |   5 +-
 .../AdministrativeData.CoreDataType.test.ts   |   5 +-
 .../AdministrativeData.Items.Item.test.ts     |   5 +-
 .../AdministrativeData.Items.test.ts          |   5 +-
 ...surementResult.InfluenceConditions.test.ts |   5 +-
 ...surementResult.MeasuringEquipments.test.ts |   5 +-
 ...mentResults.MeasurementResult.Name.test.ts |   5 +-
 ...tResults.MeasurementResult.Results.test.ts |   5 +-
 ...ults.MeasurementResult.UsedMethods.test.ts |   5 +-
 ...strativeData.CalibrationLaboratory.test.ts |   5 +-
 .../AdministrativeData.CoreDataType.test.ts   |   5 +-
 .../AdministrativeData.Customer.test.ts       |   5 +-
 .../AdministrativeData.Items.test.ts          |   5 +-
 .../AdministrativeData.RespPersons.test.ts    |   5 +-
 ...dministrativeData.SoftwareListType.test.ts |   5 +-
 .../DigitalCalibrationCertificateType.test.ts |   5 +-
 ...mentResults.MeasurementResult.Name.test.ts |   5 +-
 ...tResults.MeasurementResult.Results.test.ts |   5 +-
 .../CalibrationLaboratory.ts                  |   2 +-
 .../common/AdministrativeData/CoreDataType.ts |   2 +-
 .../common/AdministrativeData/RespPersons.ts  |   2 +-
 tests/DCC/common/Types/ContactType.ts         |   2 +-
 tests/DCC/common/Types/DataType.ts            |   3 +-
 tests/DCC/common/Types/RespPersonType.ts      |   4 +-
 tests/DCC/common/Types/StatementListType.ts   |   2 +-
 .../DCC/common/Types/StatementMetaDataType.ts |   4 +-
 tests/DCCDocument.test.ts                     |   5 +-
 tests/GP_Temperature/CharsXMLList.test.ts     |   5 +-
 tests/GP_Temperature/noQuantity.test.ts       |   5 +-
 tests/XMLEnvironment.ts                       |  44 ----
 tests/index.d.ts                              |  12 -
 tests/tsconfig.json                           |   8 +-
 tests/vitest-environment-custom/index.ts      |  48 ++++
 tests/vitest-environment-custom/package.json  |   5 +
 tsconfig.json                                 |   2 +-
 vite.config.ts                                |  23 ++
 yarn.lock                                     | Bin 181269 -> 146319 bytes
 91 files changed, 804 insertions(+), 303 deletions(-)
 create mode 100644 auto-imports.d.ts
 delete mode 100644 jest.config.ts
 create mode 100644 tests/DCC/AdministrativeData.CalibrationLaboratory.test.ts
 create mode 100644 tests/DCC/AdministrativeData.CoreDataType.test.ts
 create mode 100644 tests/DCC/AdministrativeData.Customer.test.ts
 create mode 100644 tests/DCC/AdministrativeData.RespPersons.test.ts
 create mode 100644 tests/DCC/AdministrativeData.Statements.test.ts
 delete mode 100644 tests/XMLEnvironment.ts
 delete mode 100644 tests/index.d.ts
 create mode 100644 tests/vitest-environment-custom/index.ts
 create mode 100644 tests/vitest-environment-custom/package.json
 create mode 100644 vite.config.ts

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 9f2bc57..5a71494 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -50,14 +50,21 @@ unit_tests:
   needs: ["proxy"]
   script:
     - *yarn-install
-    - yarn run test:unit --ci
+    - yarn run test:unit --coverage
+  coverage: '/Lines\s*: \d+\.\d+/'
   cache:
     - <<: *yarn-cache
   artifacts:
     when: always
+    paths:
+      - junit.xml
+      - coverage/cobertura-coverage.xml
     reports:
       junit:
         - junit.xml
+      coverage_report:
+        coverage_format: cobertura
+        path: coverage/cobertura-coverage.xml
 
 
 # === Job: ESLint and Prettier ===
diff --git a/auto-imports.d.ts b/auto-imports.d.ts
new file mode 100644
index 0000000..cddd3f3
--- /dev/null
+++ b/auto-imports.d.ts
@@ -0,0 +1,20 @@
+/* eslint-disable */
+/* prettier-ignore */
+// @ts-nocheck
+// Generated by unplugin-auto-import
+export {}
+declare global {
+  const afterAll: typeof import('vitest')['afterAll']
+  const afterEach: typeof import('vitest')['afterEach']
+  const assert: typeof import('vitest')['assert']
+  const beforeAll: typeof import('vitest')['beforeAll']
+  const beforeEach: typeof import('vitest')['beforeEach']
+  const chai: typeof import('vitest')['chai']
+  const describe: typeof import('vitest')['describe']
+  const expect: typeof import('vitest')['expect']
+  const it: typeof import('vitest')['it']
+  const suite: typeof import('vitest')['suite']
+  const test: typeof import('vitest')['test']
+  const vi: typeof import('vitest')['vi']
+  const vitest: typeof import('vitest')['vitest']
+}
diff --git a/jest.config.ts b/jest.config.ts
deleted file mode 100644
index 1e5b8e4..0000000
--- a/jest.config.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import type { JestConfigWithTsJest } from "ts-jest";
-
-const config: JestConfigWithTsJest = {
-  preset: "ts-jest",
-  testEnvironment: "node",
-  reporters: ["default", "jest-junit"],
-  coverageProvider: "v8",
-  transform: {
-    "^.+\\.m?[tj]sx?$": [
-      "ts-jest",
-      {
-        tsconfig: "tests/tsconfig.json",
-      },
-    ],
-  },
-};
-
-export default config;
diff --git a/package.json b/package.json
index b236348..cf2231e 100644
--- a/package.json
+++ b/package.json
@@ -17,7 +17,7 @@
     "test": "concurrently -m 1  \"npm:test:*\"",
     "test:lint": "eslint src --ext .ts",
     "test:prettier": "prettier \"src/**/*.ts\" --list-different",
-    "test:unit": "jest",
+    "test:unit": "vitest",
     "prepack": "npx rimraf lib && yarn run build",
     "prepublish": "yarn run test"
   },
@@ -25,24 +25,22 @@
     "xml-js": "^1.6.11"
   },
   "devDependencies": {
-    "@jest/globals": "^29.5.0",
-    "@types/jest": "^29.5.1",
-    "@types/node": "^18.16.2",
-    "@typescript-eslint/eslint-plugin": "^5.56.0",
-    "@typescript-eslint/parser": "^5.56.0",
+    "@types/node": "^18.16.18",
+    "@typescript-eslint/eslint-plugin": "^5.60.0",
+    "@typescript-eslint/parser": "^5.60.0",
+    "@vitest/coverage-istanbul": "^0.32.2",
     "concurrently": "^8.2.0",
-    "eslint": "^8.36.0",
+    "eslint": "^8.43.0",
     "eslint-config-prettier": "^8.8.0",
-    "fast-check": "^3.7.1",
-    "jest": "^29.5.0",
-    "jest-environment-node": "^29.5.0",
-    "jest-junit": "^16.0.0",
-    "jsdom": "^21.1.1",
+    "fast-check": "^3.10.0",
+    "jsdom": "^22.1.0",
     "lodash": "^4.17.21",
-    "prettier": "^2.8.6",
-    "ts-jest": "^29.1.0",
+    "prettier": "^2.8.8",
     "ts-node": "^10.9.1",
-    "typescript": "^4.9.5",
+    "typescript": "^5.1.3",
+    "unplugin-auto-import": "^0.16.4",
+    "vitest": "^0.32.2",
+    "vitest-environment-custom": "link:./tests/vitest-environment-custom",
     "xpath-ts": "^1.3.13"
   },
   "publishConfig": {
diff --git a/tests/DCC/AdministrativeData.CalibrationLaboratory.test.ts b/tests/DCC/AdministrativeData.CalibrationLaboratory.test.ts
new file mode 100644
index 0000000..60139b1
--- /dev/null
+++ b/tests/DCC/AdministrativeData.CalibrationLaboratory.test.ts
@@ -0,0 +1,79 @@
+/**
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { CalibrationLaboratoryType, DCCDocument } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:calibrationLaboratory/dcc:contact";
+const xpath = {
+  name: `string(${base}/dcc:name/dcc:content)`,
+  eMail: `string(${base}/dcc:eMail)`,
+  phone: `string(${base}/dcc:phone)`,
+  fax: `string(${base}/dcc:fax)`,
+  location: {
+    city: `${base}/dcc:location/dcc:city`,
+    countryCode: `${base}/dcc:location/dcc:countryCode`,
+    postCode: `${base}/dcc:location/dcc:postCode`,
+    street: `${base}/dcc:location/dcc:street`,
+    streetNo: `${base}/dcc:location/dcc:streetNo`,
+    further: `${base}/dcc:location/dcc:further/dcc:content`,
+  },
+};
+
+describe("CalibrationLaboratoryType", () => {
+  let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = recreateEnv());
+    calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
+  });
+
+  test("should get correct name from XML", () => {
+    expect(calibrationLaboratory.contact.name.content[0]._text).toBe(select(xpath.name, dom));
+  });
+
+  test("should get correct eMail from XML", () => {
+    expect(calibrationLaboratory.contact.eMail._text).toBe(select(xpath.eMail, dom));
+  });
+
+  test("should get correct phone from XML", () => {
+    expect(calibrationLaboratory.contact.phone._text).toBe(select(xpath.phone, dom));
+  });
+
+  test("should get correct city from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.city, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.city)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct countryCode from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.countryCode, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.countryCode)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct postCode from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.postCode, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.postCode)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct street from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.street, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.street)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct streetNo from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.streetNo, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.streetNo)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct further element from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.further, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.further[0].content)).toEqual(toTextContentArr(expected));
+  });
+});
diff --git a/tests/DCC/AdministrativeData.CoreDataType.test.ts b/tests/DCC/AdministrativeData.CoreDataType.test.ts
new file mode 100644
index 0000000..5f62a27
--- /dev/null
+++ b/tests/DCC/AdministrativeData.CoreDataType.test.ts
@@ -0,0 +1,119 @@
+/**
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
+ */
+
+import * as fc from "fast-check";
+import { indexOf, select, toTextArr, toTextContentArr } from "../util";
+import { CoreDataType, DCCDocument, DCCXMLElement } from "../../src";
+import { string_ISO639_1 } from "../Arbitraries";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:coreData";
+const xpath = {
+  coreData: {
+    countryCodeISO3166_1: `string(${base}/dcc:countryCodeISO3166_1)`,
+    usedLangCodeISO639_1: `${base}/dcc:usedLangCodeISO639_1`,
+    mandatoryLangCodeISO639_1: `${base}/dcc:mandatoryLangCodeISO639_1`,
+    uniqueIdentifier: `string(${base}/dcc:uniqueIdentifier)`,
+    identifications: {
+      identification: {
+        issuer: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+        value: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:value)`,
+        name: {
+          content: `${base}/dcc:identifications/dcc:identification[1]/dcc:name/dcc:content`,
+        },
+      },
+    },
+    receiptDate: `string(${base}/dcc:receiptDate)`,
+    beginPerformanceDate: `string(${base}/dcc:beginPerformanceDate)`,
+    endPerformanceDate: `string(${base}/dcc:endPerformanceDate)`,
+    performanceLocation: `string(${base}/dcc:performanceLocation)`,
+  },
+};
+
+describe("CoreDataType", () => {
+  let dcc: DCCDocument, coreData: CoreDataType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = recreateEnv());
+    coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
+  });
+
+  test("should get correct countryCodeISO3166_1 from XML", () => {
+    expect(coreData.countryCodeISO3166_1._text).toBe(select(xpath.coreData.countryCodeISO3166_1, dom));
+  });
+
+  test("should get correct usedLangCodeISO639_1 from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dom);
+    expect(toTextArr(coreData.usedLangCodeISO639_1)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct mandatoryLangCodeISO639_1 from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.coreData.mandatoryLangCodeISO639_1, dom);
+    expect(toTextArr(coreData.mandatoryLangCodeISO639_1)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct unique identifier from XML", () => {
+    expect(coreData.uniqueIdentifier._text).toBe(select(xpath.coreData.uniqueIdentifier, dom));
+  });
+
+  test("should get correct identification issuer from XML", () => {
+    expect(coreData.identifications.identification[0].issuer._text).toBe(select(xpath.coreData.identifications.identification.issuer, dom));
+  });
+
+  test("should get correct identification value from XML", () => {
+    expect(coreData.identifications.identification[0].value._text).toBe(select(xpath.coreData.identifications.identification.value, dom));
+  });
+
+  test("should get correct identification name content from XML", () => {
+    const expected = <Element[]>select(xpath.coreData.identifications.identification.name.content, dom);
+    expect(toTextArr(coreData.identifications.identification[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct receipt date from XML", () => {
+    expect(coreData.receiptDate._text).toBe(select(xpath.coreData.receiptDate, dom));
+  });
+  test("should get correct begin performance date from XML", () => {
+    expect(coreData.beginPerformanceDate._text).toBe(select(xpath.coreData.beginPerformanceDate, dom));
+  });
+  test("should get correct end performance date from XML", () => {
+    expect(coreData.endPerformanceDate._text).toBe(select(xpath.coreData.endPerformanceDate, dom));
+  });
+  test("should get correct performance location from XML", () => {
+    expect(coreData.performanceLocation._text).toBe(select(xpath.coreData.performanceLocation, dom));
+  });
+
+  /* test for setters */
+  test("should set usedLangCodeISO639_1 correctly", () => {
+    fc.assert(
+      fc.property(string_ISO639_1(), (str) => {
+        // add new element to array
+        coreData.usedLangCodeISO639_1.push(new DCCXMLElement({ _text: str }));
+
+        // get actual list from xml
+        const actual = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dcc);
+
+        expect(toTextArr(coreData.usedLangCodeISO639_1)).toContain(str);
+        expect(toTextContentArr(actual)).toContain(str);
+      }),
+    );
+  });
+
+  test("should delete usedLangCodeISO639_1 correctly", () => {
+    const selection = toTextContentArr(<Element[]>select(xpath.coreData.usedLangCodeISO639_1, dom));
+    fc.assert(
+      fc.property(fc.constantFrom(...selection), (str) => {
+        // get index and remove element from array
+        const index = indexOf(coreData.usedLangCodeISO639_1, str);
+        coreData.usedLangCodeISO639_1.splice(index, 1);
+
+        // get actual list from xml
+        const actual = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dcc);
+
+        expect(toTextArr(coreData.usedLangCodeISO639_1)).not.toContain(str);
+        expect(toTextContentArr(actual)).not.toContain(str);
+      }),
+    );
+  });
+});
diff --git a/tests/DCC/AdministrativeData.Customer.test.ts b/tests/DCC/AdministrativeData.Customer.test.ts
new file mode 100644
index 0000000..911936b
--- /dev/null
+++ b/tests/DCC/AdministrativeData.Customer.test.ts
@@ -0,0 +1,76 @@
+/**
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { ContactType, DCCDocument, LocationType } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:customer";
+const xpath = {
+  customer: {
+    name: {
+      content: `${base}/dcc:name/dcc:content`,
+    },
+    email: `string(${base}/dcc:eMail)`,
+    phone: `string(${base}/dcc:phone)`,
+    fax: `string(${base}/dcc:fax)`,
+    location: {
+      city: `${base}/dcc:location/dcc:city[1]`,
+      countryCode: `${base}/dcc:location/dcc:countryCode[1]`,
+      postCode: `${base}/dcc:location/dcc:postCode[1]`,
+      postBoxOffice: `${base}/dcc:location/dcc:postBoxOffice[1]`,
+      state: `${base}/dcc:location/dcc:state[1]`,
+      street: `${base}/dcc:location/dcc:street[1]`,
+      streetNo: `${base}/dcc:location/dcc:streetNo[1]`,
+      further: `${base}/dcc:location/dcc:further[1]/dcc:content`,
+      positionCoordinates: `${base}/dcc:location/dcc:positionCoordinates[1]`,
+    },
+    descriptionData: `${base}/dcc:descriptionData`,
+    _id: `${base}/@id`,
+  },
+};
+
+describe("ContactType", () => {
+  let dcc: DCCDocument, customer: ContactType, location: LocationType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = recreateEnv());
+    customer = dcc.digitalCalibrationCertificate.administrativeData.customer;
+    location = customer.location; /* TODO: check iff this variable is used anywhere */
+  });
+
+  test("should get correct customer name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.customer.name.content, dom);
+    expect(toTextArr(customer.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct customer email address from XML", () => {
+    expect(customer.eMail._text).toBe(select(xpath.customer.email, dom));
+  });
+
+  test("should get correct customer location city from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.city, dom);
+    expect(customer.location.city[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location county code from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.countryCode, dom);
+    expect(customer.location.countryCode[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location post code from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.postCode, dom);
+    expect(customer.location.postCode[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location further from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.further, dom);
+
+    for (let i = 0; i < expected.length; i++) {
+      expect(customer.location.further[0].content[i]._text).toBe(expected[i].textContent);
+    }
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/AdministrativeData.Items.test.ts b/tests/DCC/AdministrativeData.Items.test.ts
index 79dfe54..ce71db4 100644
--- a/tests/DCC/AdministrativeData.Items.test.ts
+++ b/tests/DCC/AdministrativeData.Items.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -51,7 +50,7 @@ describe("ItemType", () => {
   let dcc: DCCDocument, item: ItemType, identification1, identification2, identification3: IdentificationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
     identification1 = item.identifications.identification[0];
     identification2 = item.identifications.identification[1];
diff --git a/tests/DCC/AdministrativeData.RespPersons.test.ts b/tests/DCC/AdministrativeData.RespPersons.test.ts
new file mode 100644
index 0000000..101c5d2
--- /dev/null
+++ b/tests/DCC/AdministrativeData.RespPersons.test.ts
@@ -0,0 +1,55 @@
+/**
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { RespPersonType, DCCDocument } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:respPersons";
+const xpath = {
+  respPersons: {
+    respPerson1: {
+      person: {
+        name: {
+          content: `${base}/dcc:respPerson[1]/dcc:person/dcc:name/dcc:content`,
+        },
+      },
+      mainSigner: `string(${base}/dcc:respPerson[1]/dcc:mainSigner)`,
+    },
+    respPerson2: {
+      person: {
+        name: {
+          content: `${base}/dcc:respPerson[2]/dcc:person/dcc:name/dcc:content`,
+        },
+      },
+    },
+  },
+};
+
+describe("ContactType", () => {
+  let dcc: DCCDocument, respPerson1, respPerson2: RespPersonType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = recreateEnv());
+    respPerson1 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[0];
+    respPerson2 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[1];
+  });
+
+  test("should get correct responsible person 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.respPersons.respPerson1.person.name.content, dom);
+    expect(toTextArr(respPerson1.person.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct responsible person 1 main signer flag from XML", () => {
+    expect(respPerson1.mainSigner._text).toBe(select(xpath.respPersons.respPerson1.mainSigner, dom));
+  });
+
+  test("should get correct responsible person 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.respPersons.respPerson2.person.name.content, dom);
+    expect(toTextArr(respPerson2.person.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/AdministrativeData.SoftwareListType.test.ts
index 6139807..3486290 100644
--- a/tests/DCC/AdministrativeData.SoftwareListType.test.ts
+++ b/tests/DCC/AdministrativeData.SoftwareListType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -24,7 +23,7 @@ describe("DccSoftwareType", () => {
   let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
     software = dccSoftware.software[0];
   });
diff --git a/tests/DCC/AdministrativeData.Statements.test.ts b/tests/DCC/AdministrativeData.Statements.test.ts
new file mode 100644
index 0000000..f3de295
--- /dev/null
+++ b/tests/DCC/AdministrativeData.Statements.test.ts
@@ -0,0 +1,212 @@
+/**
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { StatementMetaDataType, DCCDocument } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:statements";
+const xpath = {
+  statements: {
+    statement1: {
+      norm: `string(${base}/dcc:statement[1]/dcc:norm)`,
+      reference: `string(${base}/dcc:statement[1]/dcc:reference)`,
+      declaration: {
+        content: `${base}/dcc:statement[1]/dcc:declaration/dcc:content`,
+      },
+      refType: `string(${base}/dcc:statement[1]/@refType)`,
+    },
+    statement2: {
+      declaration: {
+        content: `${base}/dcc:statement[2]/dcc:declaration/dcc:content`,
+      },
+      data: {
+        quantity1: {
+          name: {
+            content: `${base}/dcc:statement[2]/dcc:data/dcc:quantity[1]/dcc:name/dcc:content`,
+          },
+          si_real: {
+            si_value: `string(${base}/dcc:statement[2]/dcc:data/dcc:quantity[1]/si:real/si:value)`,
+            si_unit: `string(${base}/dcc:statement[2]/dcc:data/dcc:quantity[1]/si:real/si:unit)`,
+          },
+        },
+        quantity2: {
+          name: {
+            content: `${base}/dcc:statement[2]/dcc:data/dcc:quantity[2]/dcc:name/dcc:content`,
+          },
+          si_real: {
+            si_value: `string(${base}/dcc:statement[2]/dcc:data/dcc:quantity[2]/si:real/si:value)`,
+            si_unit: `string(${base}/dcc:statement[2]/dcc:data/dcc:quantity[2]/si:real/si:unit)`,
+          },
+        },
+      },
+      refType: `string(${base}/dcc:statement[2]/@refType)`,
+    },
+    statement3: {
+      declaration: {
+        content: `${base}/dcc:statement[3]/dcc:declaration/dcc:content`,
+      },
+      respAuthority: {
+        name: {
+          content: `${base}/dcc:statement[3]/dcc:respAuthority/dcc:name/dcc:content`,
+        },
+        email: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:email)`,
+        location: {
+          city: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:city)`,
+          countryCode: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:countryCode)`,
+          postCode: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:postCode)`,
+        },
+      },
+      conformity: `string(${base}/dcc:statement[3]/dcc:conformity)`,
+      refType: `string(${base}/dcc:statement[3]/@refType)`,
+    },
+    statement4: {
+      declaration: {
+        content: `${base}/dcc:statement[4]/dcc:declaration/dcc:content`,
+      },
+      date: `string(${base}/dcc:statement[4]/dcc:date)`,
+      respAuthority: {
+        name: {
+          content: `${base}/dcc:statement[3]/dcc:respAuthority/dcc:name/dcc:content`,
+        },
+        email: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:email)`,
+        location: {
+          city: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:city)`,
+          countryCode: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:countryCode)`,
+          postCode: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:postCode)`,
+        },
+      },
+      refType: `string(${base}/dcc:statement[4]/@refType)`,
+    },
+  },
+};
+
+describe("ItemType", () => {
+  let dcc: DCCDocument, statement1, statement2, statement3, statement4: StatementMetaDataType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = recreateEnv());
+    statement1 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[0];
+    statement2 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[1];
+    statement3 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[2];
+    statement4 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[3];
+  });
+
+  test("should get correct statement 1 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement1.declaration.content, dom);
+    expect(toTextArr(statement1.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 1 norm model from XML", () => {
+    expect(statement1.norm[0]._text).toBe(select(xpath.statements.statement1.norm, dom));
+  });
+
+  test("should get correct statement 1 reference from XML", () => {
+    expect(statement1.reference[0]._text).toBe(select(xpath.statements.statement1.reference, dom));
+  });
+
+  test("should get correct statement 2 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement2.declaration.content, dom);
+    expect(toTextArr(statement2.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 2 data quantity 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement2.data.quantity1.name.content, dom);
+    expect(toTextArr(statement2.data.quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 2 data quantity 1 si:value from XML", () => {
+    expect(statement2.data.quantity[0].real.value._text).toBe(select(xpath.statements.statement2.data.quantity1.si_real.si_value, dom));
+  });
+
+  test("should get correct statement 2 data quantity 2 si:unit from XML", () => {
+    expect(statement2.data.quantity[0].real.unit._text).toBe(select(xpath.statements.statement2.data.quantity1.si_real.si_unit, dom));
+  });
+
+  test("should get correct statement 2 data quantity 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement2.data.quantity2.name.content, dom);
+    expect(toTextArr(statement2.data.quantity[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 2 data quantity 2 si:value from XML", () => {
+    expect(statement2.data.quantity[1].real.value._text).toBe(select(xpath.statements.statement2.data.quantity2.si_real.si_value, dom));
+  });
+
+  test("should get correct statement 2 data quantity 2 si:unit from XML", () => {
+    expect(statement2.data.quantity[1].real.unit._text).toBe(select(xpath.statements.statement2.data.quantity2.si_real.si_unit, dom));
+  });
+
+  test("should get correct statement 2 refType from XML", () => {
+    expect(statement2._attr.refType).toBe(select(xpath.statements.statement2.refType, dom));
+  });
+
+  test("should get correct statement 3 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement3.declaration.content, dom);
+    expect(toTextArr(statement3.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 3 responsible authority name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement3.respAuthority.name.content, dom);
+    expect(toTextArr(statement3.respAuthority.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* responsible authority 3 */
+  test("should get correct statement 3 responsible authority email from XML", () => {
+    expect(statement3.respAuthority.eMail._text).toBe(select(xpath.statements.statement3.respAuthority.email, dom));
+  });
+
+  test("should get correct statement 3 responsible authority location city from XML", () => {
+    expect(statement3.respAuthority.location.city[0]._text).toBe(select(xpath.statements.statement3.respAuthority.location.city, dom));
+  });
+  test("should get correct statement 3 responsible authority location country code from XML", () => {
+    expect(statement3.respAuthority.location.countryCode[0]._text).toBe(select(xpath.statements.statement3.respAuthority.location.countryCode, dom));
+  });
+  test("should get correct statement 3 responsible authority location post code from XML", () => {
+    expect(statement3.respAuthority.location.postCode[0]._text).toBe(select(xpath.statements.statement3.respAuthority.location.postCode, dom));
+  });
+
+  test("should get correct statement 3 conformity from XML", () => {
+    expect(statement3.conformity._text).toBe(select(xpath.statements.statement3.conformity, dom));
+  });
+
+  test("should get correct statement 3 refType from XML", () => {
+    expect(statement3._attr.refType).toBe(select(xpath.statements.statement3.refType, dom));
+  });
+
+  test("should get correct statement 4 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement4.declaration.content, dom);
+    expect(toTextArr(statement4.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 4 date from XML", () => {
+    expect(statement4.date._text).toBe(select(xpath.statements.statement4.date, dom));
+  });
+
+  /* responsible authority 4 */
+  test("should get correct statement 4 responsible authority email from XML", () => {
+    expect(statement4.respAuthority.eMail._text).toBe(select(xpath.statements.statement4.respAuthority.email, dom));
+  });
+
+  test("should get correct statement 4 responsible authority location city from XML", () => {
+    expect(statement4.respAuthority.location.city[0]._text).toBe(select(xpath.statements.statement4.respAuthority.location.city, dom));
+  });
+  test("should get correct statement 4 responsible authority location country code from XML", () => {
+    expect(statement4.respAuthority.location.countryCode[0]._text).toBe(select(xpath.statements.statement4.respAuthority.location.countryCode, dom));
+  });
+  test("should get correct statement 4 responsible authority location post code from XML", () => {
+    expect(statement4.respAuthority.location.postCode[0]._text).toBe(select(xpath.statements.statement4.respAuthority.location.postCode, dom));
+  });
+
+  test("should get correct statement 4 refType from XML", () => {
+    expect(statement4._attr.refType).toBe(select(xpath.statements.statement4.refType, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/AdministrativeData.test.ts b/tests/DCC/AdministrativeData.test.ts
index b6f6ade..920cf98 100644
--- a/tests/DCC/AdministrativeData.test.ts
+++ b/tests/DCC/AdministrativeData.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { testCalibrationLaboratory } from "./common/AdministrativeData/CalibrationLaboratory";
diff --git a/tests/DCC/DigitalCalibrationCertificateType.test.ts b/tests/DCC/DigitalCalibrationCertificateType.test.ts
index eaceec3..917b0b9 100644
--- a/tests/DCC/DigitalCalibrationCertificateType.test.ts
+++ b/tests/DCC/DigitalCalibrationCertificateType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select } from "../util";
@@ -11,7 +10,7 @@ describe("DigitalCalibrationCertificateType", () => {
   let xml, dcc, dom;
 
   beforeEach(() => {
-    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+    ({ xml, dcc, dom } = recreateEnv());
   });
 
   test("should get correct schemaVersion from XML", () => {
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CalibrationLaboratory.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CalibrationLaboratory.test.ts
index 0bf3cce..e56ab79 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CalibrationLaboratory.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CalibrationLaboratory.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -26,7 +25,7 @@ describe("GP_DCC_Temperature_Simplified: CalibrationLaboratoryType", () => {
   let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CoreDataType.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CoreDataType.test.ts
index 0c3aaf0..de86693 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CoreDataType.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CoreDataType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import * as fc from "fast-check";
@@ -34,7 +33,7 @@ describe("GP_DCC_Temperature_Simplified: CoreDataType", () => {
   let dcc: DCCDocument, coreData: CoreDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Customer.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Customer.test.ts
index 99bc252..4ecf28e 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Customer.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Customer.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -28,7 +27,7 @@ describe("GP_DCC_Temperature_Simplified: ContactType", () => {
   let dcc: DCCDocument, customer: ContactType, location: LocationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     customer = dcc.digitalCalibrationCertificate.administrativeData.customer;
     location = customer.location; /* TODO: check iff this variable is used anywhere */
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Items.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Items.test.ts
index 66f37cf..5b62ce3 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Items.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Items.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -51,7 +50,7 @@ describe("GP_DCC_Temperature_Simplified: ItemType", () => {
   let dcc: DCCDocument, item: ItemType, identification1, identification2, identification3: IdentificationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
     identification1 = item.identifications.identification[0];
     identification2 = item.identifications.identification[1];
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.RespPersons.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.RespPersons.test.ts
index 8d52086..b066bcb 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.RespPersons.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.RespPersons.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -31,7 +30,7 @@ describe("GP_DCC_Temperature_Simplified: RespPersonType", () => {
   let dcc: DCCDocument, respPerson1, respPerson2: RespPersonType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     respPerson1 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[0];
     respPerson2 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[1];
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.SoftwareListType.test.ts
index fb27ba6..e6d4a11 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.SoftwareListType.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.SoftwareListType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -20,7 +19,7 @@ describe("GP_DCC_Temperature_Simplified: DccSoftwareType", () => {
   let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
     software = dccSoftware.software[0];
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Statements.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Statements.test.ts
index f68a629..2b135b1 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Statements.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Statements.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -52,7 +51,7 @@ describe("GP_DCC_Temperature_Simplified: StatementMetaDataType", () => {
   let dcc: DCCDocument, statement1, statement2: StatementMetaDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     statement1 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[0];
     statement2 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[1];
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/DigitalCalibrationCertificateType.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/DigitalCalibrationCertificateType.test.ts
index df17932..b8a7039 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/DigitalCalibrationCertificateType.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/DigitalCalibrationCertificateType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select } from "../../util";
@@ -11,7 +10,7 @@ describe("GP_DCC_Temperature_Simplified: DigitalCalibrationCertificateType", ()
   let xml, dcc, dom;
 
   beforeEach(() => {
-    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+    ({ xml, dcc, dom } = recreateEnv());
   });
 
   test("should get correct schemaVersion from XML", () => {
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
index f989c1d..863afe1 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -84,7 +83,7 @@ describe("GP_DCC_Temperature_Simplified: InfluenceConditionListType", () => {
   let dcc: DCCDocument, influenceConditions: InfluenceConditionListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     influenceConditions = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].influenceConditions;
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
index d130350..ef4b706 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -28,7 +27,7 @@ describe("GP_DCC_Temperature_Simplified: MeasuringEquipmentType", () => {
   let dcc: DCCDocument, measuringEquipment: MeasuringEquipmentType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measuringEquipment = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].measuringEquipments.measuringEquipment[0];
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Name.test.ts
index 6fad3df..237dc63 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Name.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Name.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -21,7 +20,7 @@ describe("GP_DCC_Temperature_Simplified: MeasurementResultType", () => {
   let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Results.test.ts
index 4fd7681..eba3b9c 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Results.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Results.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -106,7 +105,7 @@ describe("GP_DCC_Temperature_Simplified: ResultType", () => {
   let dcc: DCCDocument, result: ResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.UsedMethods.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.UsedMethods.test.ts
index 6becd0f..3702d11 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.UsedMethods.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.UsedMethods.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -26,7 +25,7 @@ describe("GP_DCC_Temperature_Simplified: UsedMethodListType", () => {
   let dcc: DCCDocument, usedMethods: UsedMethodListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     usedMethods = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].usedMethods;
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Items_variant.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Items_variant.test.ts
index de4e310..68a193b 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Items_variant.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Items_variant.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified_variant.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified_variant.xml" }
  */
 
 import { select } from "../../util";
@@ -22,7 +21,7 @@ describe("GP_DCC_Temperature_Typical: ItemType", () => {
   let dcc: DCCDocument, item: ItemType, equipmentClass: EquipmentClassType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
     equipmentClass = item.equipmentClass[0];
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Statements_variant.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Statements_variant.test.ts
index 26ad9a3..2ed48e7 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Statements_variant.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Statements_variant.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified_variant.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified_variant.xml" }
  */
 
 import * as fc from "fast-check";
@@ -26,7 +25,7 @@ describe("GP_DCC_Temperature_Simplified: StatementMetaDataType", () => {
   let dcc: DCCDocument, statement3: StatementMetaDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     statement3 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[2];
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CalibrationLaboratory.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CalibrationLaboratory.test.ts
index fdaf96a..4809389 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CalibrationLaboratory.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CalibrationLaboratory.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -26,7 +25,7 @@ describe("GP_DCC_Temperature_Typical: CalibrationLaboratoryType", () => {
   let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CoreDataType.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CoreDataType.test.ts
index da8c8ee..62dfb12 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CoreDataType.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CoreDataType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import * as fc from "fast-check";
@@ -35,7 +34,7 @@ describe("GP_DCC_Temperature_Typical: CoreDataType", () => {
   let dcc: DCCDocument, coreData: CoreDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Customer.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Customer.test.ts
index e03dd5c..2c9ad6b 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Customer.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Customer.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -35,7 +34,7 @@ describe("GP_DCC_Temperature_Typical: ContactType", () => {
   let dcc: DCCDocument, customer: ContactType, location: LocationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     customer = dcc.digitalCalibrationCertificate.administrativeData.customer;
     location = customer.location; /* TODO: check iff this variable is used anywhere */
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Items.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Items.test.ts
index dce1bac..b6f216f 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Items.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Items.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -51,7 +50,7 @@ describe("GP_DCC_Temperature_Typical: ItemType", () => {
   let dcc: DCCDocument, item: ItemType, identification1, identification2, identification3: IdentificationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
     identification1 = item.identifications.identification[0];
     identification2 = item.identifications.identification[1];
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.RespPersons.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.RespPersons.test.ts
index 583b3f8..58c2b10 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.RespPersons.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.RespPersons.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -31,7 +30,7 @@ describe("GP_DCC_Temperature_Typical: RespPersonType", () => {
   let dcc: DCCDocument, respPerson1, respPerson2: RespPersonType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     respPerson1 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[0];
     respPerson2 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[1];
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.SoftwareListType.test.ts
index cb02695..e08ed62 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.SoftwareListType.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.SoftwareListType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -22,7 +21,7 @@ describe("GP_DCC_Temperature_Typical: DccSoftwareType", () => {
   let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
     software = dccSoftware.software[0];
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Statements.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Statements.test.ts
index 0c5ae36..147a798 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Statements.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Statements.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -86,7 +85,7 @@ describe("GP_DCC_Temperature_Typical: StatementMetaDataType", () => {
   let dcc: DCCDocument, statement1, statement2, statement3, statement4: StatementMetaDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     statement1 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[0];
     statement2 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[1];
     statement3 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[2];
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/DigitalCalibrationCertificateType.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/DigitalCalibrationCertificateType.test.ts
index 110f096..f7b0a34 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/DigitalCalibrationCertificateType.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/DigitalCalibrationCertificateType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select } from "../../util";
@@ -11,7 +10,7 @@ describe("GP_DCC_Temperature_Typical: DigitalCalibrationCertificateType", () =>
   let xml, dcc, dom;
 
   beforeEach(() => {
-    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+    ({ xml, dcc, dom } = recreateEnv());
   });
 
   test("should get correct schemaVersion from XML", () => {
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
index 436f8d3..9ab5918 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -103,7 +102,7 @@ describe("GP_DCC_Temperature_Typical: InfluenceConditionListType", () => {
   let dcc: DCCDocument, influenceConditions: InfluenceConditionListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     influenceConditions = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].influenceConditions;
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
index 856134e..0ec9d18 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -28,7 +27,7 @@ describe("GP_DCC_Temperature_Typical: MeasuringEquipmentType", () => {
   let dcc: DCCDocument, measuringEquipment: MeasuringEquipmentType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measuringEquipment = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].measuringEquipments.measuringEquipment[0];
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Name.test.ts
index 892a1f3..076be1a 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Name.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Name.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -21,7 +20,7 @@ describe("GP_DCC_Temperature_Typical: MeasurementResultType", () => {
   let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Results.test.ts
index 9efe9ae..6920a11 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Results.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Results.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -101,7 +100,7 @@ describe("GP_DCC_Temperature_Typical: ResultType", () => {
   let dcc: DCCDocument, result: ResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.UsedMethods.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.UsedMethods.test.ts
index 4738344..1fc11df 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.UsedMethods.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.UsedMethods.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -39,7 +38,7 @@ describe("GP_DCC_Temperature_Typical: UsedMethodListType", () => {
   let dcc: DCCDocument, usedMethods: UsedMethodListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     usedMethods = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].usedMethods;
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CalibrationLaboratory.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CalibrationLaboratory.test.ts
index 2e618ce..a62165f 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CalibrationLaboratory.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CalibrationLaboratory.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -26,7 +25,7 @@ describe("GP_Temperature_v3.2.0_DCC: CalibrationLaboratoryType", () => {
   let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CoreDataType.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CoreDataType.test.ts
index 4affcd1..773f073 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CoreDataType.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CoreDataType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import * as fc from "fast-check";
@@ -36,7 +35,7 @@ describe("GP_Temperature_v3.2.0_DCC: CoreDataType", () => {
   let dcc: DCCDocument, coreData: CoreDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Customer.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Customer.test.ts
index af5a456..4404f78 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Customer.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Customer.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -28,7 +27,7 @@ describe("GP_Temperature_v3.2.0_DCC: ContactType", () => {
   let dcc: DCCDocument, customer: ContactType, location: LocationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     customer = dcc.digitalCalibrationCertificate.administrativeData.customer;
     location = customer.location; /* TODO: check iff this variable is used anywhere */
   });
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Items.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Items.test.ts
index f1d47d2..e5e1e48 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Items.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Items.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -62,7 +61,7 @@ describe("GP_Temperature_v3.2.0_DCC: ItemType", () => {
   let dcc: DCCDocument, item: ItemType, identification1, identification2, identification3: IdentificationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
     identification1 = item.identifications.identification[0];
     identification2 = item.identifications.identification[1];
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RefTypeDefinitons.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RefTypeDefinitons.test.ts
index 55167b5..25f3e65 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RefTypeDefinitons.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RefTypeDefinitons.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -28,7 +27,7 @@ describe("GP_Temperature_v3.2.0_DCC: RefTypeDefinitionType", () => {
   let dcc: DCCDocument, refTypeDefinition: RefTypeDefinitionType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     refTypeDefinition = dcc.digitalCalibrationCertificate.administrativeData.refTypeDefinitions.refTypeDefinition[0];
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RespPersons.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RespPersons.test.ts
index a2ac963..73c8b82 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RespPersons.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RespPersons.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -31,7 +30,7 @@ describe("GP_Temperature_v3.2.0_DCC: RespPersonType", () => {
   let dcc: DCCDocument, respPerson1, respPerson2: RespPersonType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     respPerson1 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[0];
     respPerson2 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[1];
   });
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.SoftwareListType.test.ts
index fd5381e..95c0088 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.SoftwareListType.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.SoftwareListType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -27,7 +26,7 @@ describe("GP_Temperature_v3.2.0_DCC: DccSoftwareType", () => {
   let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
     software = dccSoftware.software[0];
   });
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Statements.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Statements.test.ts
index 9cf4423..b943a0a 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Statements.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Statements.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -52,7 +51,7 @@ describe("GP_Temperature_v3.2.0_DCC: StatementMetaDataType", () => {
   let dcc: DCCDocument, statement1, statement2: StatementMetaDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     statement1 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[0];
     statement2 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[1];
   });
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/DigitalCalibrationCertificateType.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/DigitalCalibrationCertificateType.test.ts
index c279ef1..467d936 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/DigitalCalibrationCertificateType.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/DigitalCalibrationCertificateType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select } from "../../util";
@@ -11,7 +10,7 @@ describe("GP_Temperature_v3.2.0_DCC: DigitalCalibrationCertificateType", () => {
   let xml, dcc, dom;
 
   beforeEach(() => {
-    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+    ({ xml, dcc, dom } = recreateEnv());
   });
 
   test("should get correct schemaVersion from XML", () => {
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
index d40fa27..ce1bb26 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -84,7 +83,7 @@ describe("GP_Temperature_v3.2.0_DCC: InfluenceConditionListType", () => {
   let dcc: DCCDocument, influenceConditions: InfluenceConditionListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     influenceConditions = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].influenceConditions;
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
index 9a03c23..ffdb5cd 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -28,7 +27,7 @@ describe("GP_Temperature_v3.2.0_DCC: MeasuringEquipmentType", () => {
   let dcc: DCCDocument, measuringEquipment: MeasuringEquipmentType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measuringEquipment = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].measuringEquipments.measuringEquipment[0];
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Name.test.ts
index 903a524..05660a4 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Name.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Name.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -21,7 +20,7 @@ describe("GP_Temperature_v3.2.0_DCC: MeasurementResultType", () => {
   let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Results.test.ts
index 0198891..63aa159 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Results.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Results.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -206,7 +205,7 @@ describe("GP_Temperature_v3.2.0_DCC: ResultType", () => {
   let dcc: DCCDocument, result: ResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
index 1651c10..8352a94 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -26,7 +25,7 @@ describe("GP_Temperature_v3.2.0_DCC: UsedMethodListType", () => {
   let dcc: DCCDocument, usedMethods: UsedMethodListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     usedMethods = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].usedMethods;
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.CoreDataType.test.ts b/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.CoreDataType.test.ts
index 7d9e8e7..8df1fe8 100644
--- a/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.CoreDataType.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.CoreDataType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.1_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.1_DCC.xml" }
  */
 
 import { select } from "../../util";
@@ -20,7 +19,7 @@ describe("GP_Temperature_v3.2.1_DCC: CoreDataType", () => {
   let dcc: DCCDocument, coreData: CoreDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.Item.test.ts b/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.Item.test.ts
index 08474c9..12eb493 100644
--- a/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.Item.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.Item.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.1_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.1_DCC.xml" }
  */
 
 import { DCCDocument, ItemType } from "../../../src";
@@ -9,7 +8,7 @@ describe("GP_Temperature_v3.2.1_DCC: ItemType", () => {
   let dcc: DCCDocument, item: ItemType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.test.ts b/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.test.ts
index 632535f..ac03d09 100644
--- a/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.1_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.1_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -21,7 +20,7 @@ describe("GP_Temperature_v3.2.1_DCC: ItemListType", () => {
   let dcc: DCCDocument, items: ItemListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     items = dcc.digitalCalibrationCertificate.administrativeData.items;
   });
 
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
index 5f4974e..4607750 100644
--- a/tests/DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
+++ b/tests/DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -103,7 +102,7 @@ describe("InfluenceConditionListType", () => {
   let dcc: DCCDocument, influenceConditions: InfluenceConditionListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     influenceConditions = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].influenceConditions;
   });
 
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
index 8107d84..187b54d 100644
--- a/tests/DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
+++ b/tests/DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -28,7 +27,7 @@ describe("MeasuringEquipmentType", () => {
   let dcc: DCCDocument, measuringEquipment: MeasuringEquipmentType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measuringEquipment = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].measuringEquipments.measuringEquipment[0];
   });
 
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.Name.test.ts
index 1828f27..1dc5e99 100644
--- a/tests/DCC/MeasurementResults.MeasurementResult.Name.test.ts
+++ b/tests/DCC/MeasurementResults.MeasurementResult.Name.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -21,7 +20,7 @@ describe("MeasurementResultType", () => {
   let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
   });
 
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.Results.test.ts
index 64536b7..39e6b5e 100644
--- a/tests/DCC/MeasurementResults.MeasurementResult.Results.test.ts
+++ b/tests/DCC/MeasurementResults.MeasurementResult.Results.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -101,7 +100,7 @@ describe("ResultType", () => {
   let dcc: DCCDocument, result: ResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
   });
 
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
index 54cdf56..cb502b6 100644
--- a/tests/DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
+++ b/tests/DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -39,7 +38,7 @@ describe("UsedMethodListType", () => {
   let dcc: DCCDocument, usedMethods: UsedMethodListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     usedMethods = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].usedMethods;
   });
 
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.CalibrationLaboratory.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.CalibrationLaboratory.test.ts
index 3529e3b..43fc202 100644
--- a/tests/DCC/Test_DCC_Minimal/AdministrativeData.CalibrationLaboratory.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.CalibrationLaboratory.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -18,7 +17,7 @@ describe("Test_DCC_Minimal: CalibrationLaboratoryType", () => {
   let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
   });
 
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.CoreDataType.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.CoreDataType.test.ts
index e9ca47c..758923e 100644
--- a/tests/DCC/Test_DCC_Minimal/AdministrativeData.CoreDataType.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.CoreDataType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import * as fc from "fast-check";
@@ -34,7 +33,7 @@ describe("Test_DCC_Minimal: CoreDataType", () => {
   let dcc: DCCDocument, coreData: CoreDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
   });
 
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.Customer.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.Customer.test.ts
index 3888155..c060405 100644
--- a/tests/DCC/Test_DCC_Minimal/AdministrativeData.Customer.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.Customer.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -22,7 +21,7 @@ describe("Test_DCC_Minimal: ContactType", () => {
   let dcc: DCCDocument, customer: ContactType, location: LocationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     customer = dcc.digitalCalibrationCertificate.administrativeData.customer;
     location = customer.location; /* TODO: check iff this variable is used anywhere */
   });
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.Items.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.Items.test.ts
index 958427c..0479cb5 100644
--- a/tests/DCC/Test_DCC_Minimal/AdministrativeData.Items.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.Items.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -35,7 +34,7 @@ describe("Test_DCC_Minimal: ItemType", () => {
   let dcc: DCCDocument, item: ItemType, identification: IdentificationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
     identification = item.identifications.identification[0];
   });
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.RespPersons.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.RespPersons.test.ts
index 7c74d61..3587b34 100644
--- a/tests/DCC/Test_DCC_Minimal/AdministrativeData.RespPersons.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.RespPersons.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -23,7 +22,7 @@ describe("Test_DCC_Minimal: RespPersonType", () => {
   let dcc: DCCDocument, respPerson: RespPersonType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     respPerson = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[0];
   });
 
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.SoftwareListType.test.ts
index 3577e44..cacf9e4 100644
--- a/tests/DCC/Test_DCC_Minimal/AdministrativeData.SoftwareListType.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.SoftwareListType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -24,7 +23,7 @@ describe("Test_DCC_Minimal: DccSoftwareType", () => {
   let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
     software = dccSoftware.software[0];
   });
diff --git a/tests/DCC/Test_DCC_Minimal/DigitalCalibrationCertificateType.test.ts b/tests/DCC/Test_DCC_Minimal/DigitalCalibrationCertificateType.test.ts
index 1f0006a..ef82732 100644
--- a/tests/DCC/Test_DCC_Minimal/DigitalCalibrationCertificateType.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/DigitalCalibrationCertificateType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select } from "../../util";
@@ -11,7 +10,7 @@ describe("Test_DCC_Minimal: DigitalCalibrationCertificateType", () => {
   let xml, dcc, dom;
 
   beforeEach(() => {
-    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+    ({ xml, dcc, dom } = recreateEnv());
   });
 
   test("should get correct schemaVersion from XML", () => {
diff --git a/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Name.test.ts
index bd50cc0..ec2478b 100644
--- a/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Name.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Name.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -21,7 +20,7 @@ describe("Test_DCC_Minimal: MeasurementResultType", () => {
   let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
   });
 
diff --git a/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Results.test.ts
index 06a0973..4e6f9a0 100644
--- a/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Results.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Results.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -48,7 +47,7 @@ describe("Test_DCC_Minimal: ResultType", () => {
   let dcc: DCCDocument, result: ResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
   });
 
diff --git a/tests/DCC/common/AdministrativeData/CalibrationLaboratory.ts b/tests/DCC/common/AdministrativeData/CalibrationLaboratory.ts
index 25a455d..a6afc21 100644
--- a/tests/DCC/common/AdministrativeData/CalibrationLaboratory.ts
+++ b/tests/DCC/common/AdministrativeData/CalibrationLaboratory.ts
@@ -23,7 +23,7 @@ export const testCalibrationLaboratory = () => {
     let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
 
     beforeEach(() => {
-      ({ dcc, dom } = xmlEnv.recreateEnv());
+      ({ dcc, dom } = recreateEnv());
       calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
     });
 
diff --git a/tests/DCC/common/AdministrativeData/CoreDataType.ts b/tests/DCC/common/AdministrativeData/CoreDataType.ts
index ea974a5..279e2a0 100644
--- a/tests/DCC/common/AdministrativeData/CoreDataType.ts
+++ b/tests/DCC/common/AdministrativeData/CoreDataType.ts
@@ -31,7 +31,7 @@ export const testCoreData = () => {
     let dcc: DCCDocument, coreData: CoreDataType, dom;
 
     beforeEach(() => {
-      ({ dcc, dom } = xmlEnv.recreateEnv());
+      ({ dcc, dom } = recreateEnv());
       coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
     });
 
diff --git a/tests/DCC/common/AdministrativeData/RespPersons.ts b/tests/DCC/common/AdministrativeData/RespPersons.ts
index 88495a0..79ce09c 100644
--- a/tests/DCC/common/AdministrativeData/RespPersons.ts
+++ b/tests/DCC/common/AdministrativeData/RespPersons.ts
@@ -7,7 +7,7 @@ const xpath = {
 };
 export const testRespPersonListType = () => {
   describe("RespPersonListType", () => {
-    const { dom } = xmlEnv.recreateEnv();
+    const { dom } = recreateEnv();
 
     const expectedRespPersons = <Element[]>select(xpath.respPerson, dom);
     for (let i = 0; i < expectedRespPersons.length; i++) {
diff --git a/tests/DCC/common/Types/ContactType.ts b/tests/DCC/common/Types/ContactType.ts
index 07b0d21..1428d9f 100644
--- a/tests/DCC/common/Types/ContactType.ts
+++ b/tests/DCC/common/Types/ContactType.ts
@@ -30,7 +30,7 @@ export const testContactType = (base: string, contactTypeFn: (dcc: DCCDocument)
     let dcc: DCCDocument, contactType: ContactType | ContactNotStrictType, dom;
 
     beforeEach(() => {
-      ({ dcc, dom } = xmlEnv.recreateEnv());
+      ({ dcc, dom } = recreateEnv());
       contactType = contactTypeFn(dcc);
     });
 
diff --git a/tests/DCC/common/Types/DataType.ts b/tests/DCC/common/Types/DataType.ts
index e39bb76..86ac66b 100644
--- a/tests/DCC/common/Types/DataType.ts
+++ b/tests/DCC/common/Types/DataType.ts
@@ -12,10 +12,11 @@ export const testDataType = (base: string, dataTypeFn: (dcc: DCCDocument) => Dat
     let dcc: DCCDocument, dataType: DataType, dom;
 
     beforeEach(() => {
-      ({ dcc, dom } = xmlEnv.recreateEnv());
+      ({ dcc, dom } = recreateEnv());
       dataType = dataTypeFn(dcc);
     });
 
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
     test("noop", () => {});
 
     // TODO(Statement): quantity with real
diff --git a/tests/DCC/common/Types/RespPersonType.ts b/tests/DCC/common/Types/RespPersonType.ts
index 4284f9e..13064d4 100644
--- a/tests/DCC/common/Types/RespPersonType.ts
+++ b/tests/DCC/common/Types/RespPersonType.ts
@@ -10,10 +10,10 @@ export const testRespPersonType = (base: string, respPersonTypeFn: (dcc: DCCDocu
 
   describe("RespPersonType", () => {
     let dcc: DCCDocument, respPersonType: RespPersonType, dom;
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
 
     beforeEach(() => {
-      ({ dcc, dom } = xmlEnv.recreateEnv());
+      ({ dcc, dom } = recreateEnv());
       respPersonType = respPersonTypeFn(dcc);
     });
 
diff --git a/tests/DCC/common/Types/StatementListType.ts b/tests/DCC/common/Types/StatementListType.ts
index 254fda4..09b54e0 100644
--- a/tests/DCC/common/Types/StatementListType.ts
+++ b/tests/DCC/common/Types/StatementListType.ts
@@ -8,7 +8,7 @@ export const testStatementListType = (base, statementListTypeFn: (dcc: DCCDocume
   };
 
   describe("StatementListType", () => {
-    const { dom } = xmlEnv.recreateEnv();
+    const { dom } = recreateEnv();
 
     const expectedStatements = <Element[]>select(xpath.statement, dom);
     for (let i = 0; i < expectedStatements.length; i++) {
diff --git a/tests/DCC/common/Types/StatementMetaDataType.ts b/tests/DCC/common/Types/StatementMetaDataType.ts
index 5e09d86..3ec8b7d 100644
--- a/tests/DCC/common/Types/StatementMetaDataType.ts
+++ b/tests/DCC/common/Types/StatementMetaDataType.ts
@@ -20,10 +20,10 @@ export const testStatementMetaDataType = (name, base: string, statementMetaDataT
 
   describe(`StatementMetaDataType ${name}`, () => {
     let dcc: DCCDocument, statementMetaDataType: StatementMetaDataType, dom;
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
 
     beforeEach(() => {
-      ({ dcc, dom } = xmlEnv.recreateEnv());
+      ({ dcc, dom } = recreateEnv());
       statementMetaDataType = statementMetaDataTypeFn(dcc);
     });
 
diff --git a/tests/DCCDocument.test.ts b/tests/DCCDocument.test.ts
index 06dccbf..8ad62d1 100644
--- a/tests/DCCDocument.test.ts
+++ b/tests/DCCDocument.test.ts
@@ -1,13 +1,12 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 describe("DCCDocument", () => {
   let xml, dcc;
 
   beforeEach(() => {
-    ({ xml, dcc } = xmlEnv.recreateEnv());
+    ({ xml, dcc } = recreateEnv());
   });
 
   test("fromXml() and toXml() should not modify XML", () => {
diff --git a/tests/GP_Temperature/CharsXMLList.test.ts b/tests/GP_Temperature/CharsXMLList.test.ts
index ac10b24..1d0f83c 100644
--- a/tests/GP_Temperature/CharsXMLList.test.ts
+++ b/tests/GP_Temperature/CharsXMLList.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select } from "../util";
@@ -15,7 +14,7 @@ describe("CharsXMLList", () => {
   let dcc: DCCDocument, dom, result;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
   });
 
diff --git a/tests/GP_Temperature/noQuantity.test.ts b/tests/GP_Temperature/noQuantity.test.ts
index 8b8bc09..4eec495 100644
--- a/tests/GP_Temperature/noQuantity.test.ts
+++ b/tests/GP_Temperature/noQuantity.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -28,7 +27,7 @@ describe("noQuantity", () => {
   let dcc: DCCDocument, dom, result;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
   });
 
diff --git a/tests/XMLEnvironment.ts b/tests/XMLEnvironment.ts
deleted file mode 100644
index 10160de..0000000
--- a/tests/XMLEnvironment.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import * as fs from "fs/promises";
-import { DCCDocument } from "../src";
-import NodeEnvironment from "jest-environment-node";
-import { JSDOM } from "jsdom";
-
-export default class XMLEnvironment extends NodeEnvironment {
-  xmlPath: string;
-  xml: string;
-
-  constructor(config, context) {
-    super(config, context);
-    const xmlPath = context.docblockPragmas["xml"];
-    if (xmlPath && typeof xmlPath === "string") {
-      this.xmlPath = xmlPath;
-    }
-  }
-
-  async setup() {
-    await super.setup();
-    if (this.xmlPath) {
-      this.xml = await this.readFile(this.xmlPath);
-    }
-    this.global.xmlEnv = this;
-  }
-
-  recreateEnv(): { xml: string; dcc: DCCDocument; dom: JSDOM } {
-    return {
-      xml: this.xml,
-      dcc: this.xml ? DCCDocument.fromXml(this.xml) : DCCDocument.createEmpty(),
-      dom: new JSDOM(this.xml, { contentType: "application/xml" }),
-    };
-  }
-
-  async readFile(path: string) {
-    // check if file exists
-    if ((await fs.stat(path)).isFile()) {
-      return await fs.readFile(path, { encoding: "utf-8" });
-    } else {
-      throw new Error(`File ${path} does not exist.`);
-    }
-  }
-}
-
-export const TestEnvironment = XMLEnvironment;
diff --git a/tests/index.d.ts b/tests/index.d.ts
deleted file mode 100644
index facbc06..0000000
--- a/tests/index.d.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import XMLEnvironment from "./XMLEnvironment";
-
-declare let xmlEnv: XMLEnvironment;
-
-declare global {
-  let xmlEnv: XMLEnvironment;
-  namespace NodeJS {
-    interface Global {
-      xmlEnv: XMLEnvironment;
-    }
-  }
-}
diff --git a/tests/tsconfig.json b/tests/tsconfig.json
index e6db6f1..564b624 100644
--- a/tests/tsconfig.json
+++ b/tests/tsconfig.json
@@ -2,9 +2,7 @@
   "compilerOptions": {
     "target": "ES6",
     "declaration": true,
-    "module": "commonjs"
-  },
-  "files": [
-    "./index.d.ts"
-  ]
+    "module": "commonjs",
+    "types": ["vitest/globals"]
+  }
 }
diff --git a/tests/vitest-environment-custom/index.ts b/tests/vitest-environment-custom/index.ts
new file mode 100644
index 0000000..c01dccf
--- /dev/null
+++ b/tests/vitest-environment-custom/index.ts
@@ -0,0 +1,48 @@
+import * as fs from "fs/promises";
+import { DCCDocument } from "../../src";
+import type { Environment } from "vitest";
+import { JSDOM } from "jsdom";
+import { builtinEnvironments } from "vitest/environments";
+
+declare global {
+  function recreateEnv(): { xml: string; dcc: DCCDocument; dom: JSDOM };
+}
+
+type Options = {
+  custom: {
+    xmlPath: string;
+  };
+};
+
+async function readFile(path: string) {
+  // check if file exists
+  if ((await fs.stat(path)).isFile()) {
+    return await fs.readFile(path, { encoding: "utf-8" });
+  } else {
+    throw new Error(`File ${path} does not exist.`);
+  }
+}
+
+export default <Environment>{
+  name: "custom",
+  async setup(global, { custom }: Options) {
+    const env = builtinEnvironments["node"];
+    const envReturn = await env.setup(global, {});
+
+    const xml = await readFile(custom.xmlPath);
+    global.recreateEnv = (): { xml: string; dcc: DCCDocument; dom: JSDOM } => {
+      return {
+        xml,
+        dcc: xml ? DCCDocument.fromXml(xml) : DCCDocument.createEmpty(),
+        dom: new JSDOM(xml, { contentType: "application/xml" }),
+      };
+    };
+
+    return {
+      async teardown(global) {
+        delete global.recreateEnv;
+        await envReturn.teardown(global);
+      },
+    };
+  },
+};
diff --git a/tests/vitest-environment-custom/package.json b/tests/vitest-environment-custom/package.json
new file mode 100644
index 0000000..a3717c6
--- /dev/null
+++ b/tests/vitest-environment-custom/package.json
@@ -0,0 +1,5 @@
+{
+  "name": "vitest-environment-custom",
+  "private": true,
+  "main": "index.ts"
+}
diff --git a/tsconfig.json b/tsconfig.json
index c5294d3..3b65aca 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -4,7 +4,7 @@
     "module": "commonjs",
     "declaration": true,
     "sourceMap": true,
-    "outDir": "./lib",
+    "outDir": "./lib"
   },
   "include": [
     "src"
diff --git a/vite.config.ts b/vite.config.ts
new file mode 100644
index 0000000..8473f68
--- /dev/null
+++ b/vite.config.ts
@@ -0,0 +1,23 @@
+/// <reference types="vitest" />
+
+import { defineConfig } from "vite";
+import AutoImport from "unplugin-auto-import/vite";
+
+export default defineConfig({
+  plugins: [
+    AutoImport({
+      imports: ["vitest"],
+      dts: true, // generate TypeScript declaration
+    }),
+  ],
+  test: {
+    globals: true,
+    environment: "custom",
+    reporters: ["default", "junit"],
+    outputFile: "junit.xml",
+    coverage: {
+      provider: "istanbul",
+      reporter: ["text-summary", "cobertura"],
+    },
+  },
+});
diff --git a/yarn.lock b/yarn.lock
index 57b5e4e98b2ffb46897ec2bb54de824096681d8a..73ae83801f85034343d96fab25c7da0d9b2a337a 100644
GIT binary patch
delta 41188
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
W6f@9Lr(~l<(-adEV++tS4h;Y@q9ly~

delta 66451
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
SM&s!lO_}tzzcgc7$P54)b)T64

-- 
GitLab